code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222 values | license stringclasses 20 values | size int64 1 1.05M |
|---|---|---|---|---|---|
import { hapTasks } from '@ohos/cangjie-build-support';
export default {
system: hapTasks, /* Built-in plugin of Hvigor. It cannot be modified. */
plugins:[] /* Custom plugin to extend the functionality of Hvigor. */
}
| 2401_82796943/Learning | 西安交通大学/吴铭-计算机2303-2236115029-仓颉算法实训作业/HarmonyOS-APP/entry/hvigorfile.ts | TypeScript | unknown | 237 |
import { appTasks } from '@ohos/cangjie-build-support';
export default {
system: appTasks, /* Built-in plugin of Hvigor. It cannot be modified. */
plugins:[] /* Custom plugin to extend the functionality of Hvigor. */
}
| 2401_82796943/Learning | 西安交通大学/吴铭-计算机2303-2236115029-仓颉算法实训作业/HarmonyOS-APP/hvigorfile.ts | TypeScript | unknown | 237 |
// Script for compiling build behavior. It is built in the build plug-in and cannot be modified currently.
export { hapTasks } from '@ohos/hvigor-ohos-plugin';
| 2401_82971030/316app | entry/hvigorfile.ts | TypeScript | unknown | 160 |
import UIAbility from '@ohos.app.ability.UIAbility';
import hilog from '@ohos.hilog';
import window from '@ohos.window';
export default class EntryAbility extends UIAbility {
onCreate(want, launchParam) {
hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate');
}
onDestroy() {
hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onDestroy');
}
onWindowStageCreate(windowStage: window.WindowStage) {
// Main window is created, set main page for this ability
hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageCreate');
windowStage.loadContent('pages/Index', (err, data) => {
if (err.code) {
hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? '');
return;
}
hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', JSON.stringify(data) ?? '');
});
}
onWindowStageDestroy() {
// Main window is destroyed, release UI related resources
hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageDestroy');
}
onForeground() {
// Ability has brought to foreground
hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onForeground');
}
onBackground() {
// Ability has back to background
hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onBackground');
}
}
| 2401_82971030/316app | entry/src/main/ets/entryability/EntryAbility.ts | TypeScript | unknown | 1,376 |
import hilog from '@ohos.hilog';
import TestRunner from '@ohos.application.testRunner';
import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry';
var abilityDelegator = undefined
var abilityDelegatorArguments = undefined
async function onAbilityCreateCallback() {
hilog.info(0x0000, 'testTag', '%{public}s', 'onAbilityCreateCallback');
}
async function addAbilityMonitorCallback(err: any) {
hilog.info(0x0000, 'testTag', 'addAbilityMonitorCallback : %{public}s', JSON.stringify(err) ?? '');
}
export default class OpenHarmonyTestRunner implements TestRunner {
constructor() {
}
onPrepare() {
hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner OnPrepare ');
}
async onRun() {
hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner onRun run');
abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments()
abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator()
var testAbilityName = abilityDelegatorArguments.bundleName + '.TestAbility'
let lMonitor = {
abilityName: testAbilityName,
onAbilityCreate: onAbilityCreateCallback,
};
abilityDelegator.addAbilityMonitor(lMonitor, addAbilityMonitorCallback)
var cmd = 'aa start -d 0 -a TestAbility' + ' -b ' + abilityDelegatorArguments.bundleName
var debug = abilityDelegatorArguments.parameters['-D']
if (debug == 'true')
{
cmd += ' -D'
}
hilog.info(0x0000, 'testTag', 'cmd : %{public}s', cmd);
abilityDelegator.executeShellCommand(cmd,
(err: any, d: any) => {
hilog.info(0x0000, 'testTag', 'executeShellCommand : err : %{public}s', JSON.stringify(err) ?? '');
hilog.info(0x0000, 'testTag', 'executeShellCommand : data : %{public}s', d.stdResult ?? '');
hilog.info(0x0000, 'testTag', 'executeShellCommand : data : %{public}s', d.exitCode ?? '');
})
hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner onRun end');
}
} | 2401_82971030/316app | entry/src/ohosTest/ets/testrunner/OpenHarmonyTestRunner.ts | TypeScript | unknown | 2,119 |
// Script for compiling build behavior. It is built in the build plug-in and cannot be modified currently.
export { appTasks } from '@ohos/hvigor-ohos-plugin'; | 2401_82971030/316app | hvigorfile.ts | TypeScript | unknown | 159 |
#!/bin/bash
# ----------------------------------------------------------------------------
# Hvigor startup script, version 1.0.0
#
# Required ENV vars:
# ------------------
# NODE_HOME - location of a Node home dir
# or
# Add /usr/local/nodejs/bin to the PATH environment variable
# ----------------------------------------------------------------------------
HVIGOR_APP_HOME=$(dirname $(readlink -f $0))
HVIGOR_WRAPPER_SCRIPT=${HVIGOR_APP_HOME}/hvigor/hvigor-wrapper.js
warn() {
echo ""
echo -e "\033[1;33m`date '+[%Y-%m-%d %H:%M:%S]'`$@\033[0m"
}
error() {
echo ""
echo -e "\033[1;31m`date '+[%Y-%m-%d %H:%M:%S]'`$@\033[0m"
}
fail() {
error "$@"
exit 1
}
# Determine node to start hvigor wrapper script
if [ -n "${NODE_HOME}" ];then
EXECUTABLE_NODE="${NODE_HOME}/bin/node"
if [ ! -x "$EXECUTABLE_NODE" ];then
fail "ERROR: NODE_HOME is set to an invalid directory,check $NODE_HOME\n\nPlease set NODE_HOME in your environment to the location where your nodejs installed"
fi
else
EXECUTABLE_NODE="node"
which ${EXECUTABLE_NODE} > /dev/null 2>&1 || fail "ERROR: NODE_HOME is not set and not 'node' command found in your path"
fi
# Check hvigor wrapper script
if [ ! -r "$HVIGOR_WRAPPER_SCRIPT" ];then
fail "ERROR: Couldn't find hvigor/hvigor-wrapper.js in ${HVIGOR_APP_HOME}"
fi
# start hvigor-wrapper script
exec "${EXECUTABLE_NODE}" \
"${HVIGOR_WRAPPER_SCRIPT}" "$@"
| 2401_82971030/316app | hvigorw | Shell | unknown | 1,419 |
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Hvigor startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
set WRAPPER_MODULE_PATH=%APP_HOME%\hvigor\hvigor-wrapper.js
set NODE_EXE=node.exe
goto start
:start
@rem Find node.exe
if defined NODE_HOME goto findNodeFromNodeHome
%NODE_EXE% --version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto execute
echo.
echo ERROR: NODE_HOME is not set and no 'node' command could be found in your PATH.
echo.
echo Please set the NODE_HOME variable in your environment to match the
echo location of your NodeJs installation.
goto fail
:findNodeFromNodeHome
set NODE_HOME=%NODE_HOME:"=%
set NODE_EXE_PATH=%NODE_HOME%/%NODE_EXE%
if exist "%NODE_EXE_PATH%" goto execute
echo.
echo ERROR: NODE_HOME is not set and no 'node' command could be found in your PATH.
echo.
echo Please set the NODE_HOME variable in your environment to match the
echo location of your NodeJs installation.
goto fail
:execute
@rem Execute hvigor
"%NODE_EXE%" %WRAPPER_MODULE_PATH% %*
if "%ERRORLEVEL%" == "0" goto hvigorwEnd
:fail
exit /b 1
:hvigorwEnd
if "%OS%" == "Windows_NT" endlocal
:end
| 2401_82971030/316app | hvigorw.bat | Batchfile | unknown | 1,545 |
package com.rahms.common.constant;
public class AutoFillConstant {
/**
* 实体类中的方法名称
*/
public static final String SET_CREATE_TIME = "setCreateTime";
public static final String SET_UPDATE_TIME = "setUpdateTime";
public static final String SET_CREATE_USER = "setCreateUser";
public static final String SET_UPDATE_USER = "setUpdateUser";
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/constant/AutoFillConstant.java | Java | unknown | 385 |
package com.rahms.common.constant;
/**
* 缓存常量类
*/
public class CacheConstant {
// 用户相关缓存
public static final String USER_CACHE_PREFIX = "user:";
public static final String USER_INFO_CACHE = "user:info:";
public static final String USER_LIST_CACHE = "user:list:";
// 老人信息相关缓存
public static final String ELDERLY_CACHE_PREFIX = "elderly:";
public static final String ELDERLY_INFO_CACHE = "elderly:info:";
public static final String ELDERLY_LIST_CACHE = "elderly:list:";
// 药品相关缓存
public static final String MEDICATION_CACHE_PREFIX = "medication:";
public static final String MEDICATION_INFO_CACHE = "medication:info:";
public static final String MEDICATION_LIST_CACHE = "medication:list:";
// 用药计划相关缓存
public static final String DRUG_PLAN_CACHE_PREFIX = "drug_plan:";
public static final String DRUG_PLAN_INFO_CACHE = "drug_plan:info:";
public static final String DRUG_PLAN_LIST_CACHE = "drug_plan:list:";
public static final String DRUG_PLAN_ACTIVE_CACHE = "drug_plan:active:";
// 健康数据相关缓存
public static final String HEALTH_DATA_CACHE_PREFIX = "health_data:";
public static final String HEALTH_DATA_LIST_CACHE = "health_data:list:";
public static final String HEALTH_DATA_STATISTICS_CACHE = "health_data:statistics:";
// 消息相关缓存
public static final String NOTIFICATION_CACHE_PREFIX = "notification:";
public static final String NOTIFICATION_LIST_CACHE = "notification:list:";
public static final String NOTIFICATION_UNREAD_COUNT_CACHE = "notification:unread_count:";
// 系统消息相关缓存
public static final String SYSTEM_MESSAGE_CACHE_PREFIX = "system_message:";
public static final String SYSTEM_MESSAGE_LIST_CACHE = "system_message:list:";
// 公告相关缓存
public static final String ANNOUNCEMENT_CACHE_PREFIX = "announcement:";
public static final String ANNOUNCEMENT_INFO_CACHE = "announcement:info:";
public static final String ANNOUNCEMENT_LIST_CACHE = "announcement:list:";
public static final String ANNOUNCEMENT_LATEST_CACHE = "announcement:latest:";
// JWT Token相关缓存
public static final String JWT_TOKEN_CACHE_PREFIX = "jwt:token:";
public static final String JWT_USER_CACHE_PREFIX = "jwt:user:";
// 缓存过期时间（秒）
public static final long CACHE_EXPIRE_SHORT = 300; // 5分钟
public static final long CACHE_EXPIRE_MEDIUM = 1800; // 30分钟
public static final long CACHE_EXPIRE_LONG = 3600; // 1小时
public static final long CACHE_EXPIRE_VERY_LONG = 7200; // 2小时
// 特殊缓存过期时间
public static final long JWT_TOKEN_EXPIRE = 7200; // JWT Token 2小时
public static final long USER_SESSION_EXPIRE = 1800; // 用户会话 30分钟
public static final long STATISTICS_CACHE_EXPIRE = 600; // 统计数据 10分钟
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/constant/CacheConstant.java | Java | unknown | 3,000 |
package com.rahms.common.constant;
public class JwtClaimsConstant {
public static final String EMP_ID = "empId";
public static final String USER_ID = "userId";
public static final String PHONE = "phone";
public static final String USERNAME = "username";
public static final String NAME = "name";
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/constant/JwtClaimsConstant.java | Java | unknown | 320 |
package com.rahms.common.constant;
/**
* 系统消息常量类
* 包含系统中使用的所有消息文本常量
*/
public class MessageConstant {
// 认证与登录相关
public static final String PASSWORD_ERROR = "密码错误";
public static final String ACCOUNT_NOT_FOUND = "账号不存在";
public static final String ACCOUNT_DISABLE = "账号已禁用";
public static final String UNKNOWN_ERROR = "未知错误";
public static final String USER_NOT_LOGIN = "用户未登录";
public static final String LOGIN_SUCCESS = "登录成功";
public static final String LOGOUT_SUCCESS = "退出成功";
public static final String REGISTER_SUCCESS = "注册成功";
public static final String UNAUTHORIZED_ACCESS = "未经授权的访问";
public static final String TOKEN_EXPIRED = "令牌已过期";
public static final String INVALID_TOKEN = "无效的令牌";
// 用户管理相关
public static final String USER_ADD_SUCCESS = "用户添加成功";
public static final String USER_UPDATE_SUCCESS = "用户信息更新成功";
public static final String USER_DELETE_SUCCESS = "用户删除成功";
public static final String USER_NOT_EXIST = "用户不存在";
public static final String USERNAME_EXISTS = "用户名已存在";
public static final String PHONE_EXISTS = "手机号已存在";
// 老人信息管理相关
public static final String ELDERLY_ADD_SUCCESS = "老人信息添加成功";
public static final String ELDERLY_UPDATE_SUCCESS = "老人信息更新成功";
public static final String ELDERLY_DELETE_SUCCESS = "老人信息删除成功";
public static final String ELDERLY_NOT_EXIST = "老人信息不存在";
public static final String ELDERLY_NOT_BELONG = "老人信息不属于当前用户";
// 药品管理相关
public static final String MEDICATION_ADD_SUCCESS = "药品添加成功";
public static final String MEDICATION_UPDATE_SUCCESS = "药品信息更新成功";
public static final String MEDICATION_DELETE_SUCCESS = "药品删除成功";
public static final String MEDICATION_NOT_EXIST = "药品不存在";
public static final String MEDICATION_NOT_BELONG = "药品不属于当前用户";
// 用药计划相关
public static final String PLAN_ADD_SUCCESS = "用药计划添加成功";
public static final String PLAN_UPDATE_SUCCESS = "用药计划更新成功";
public static final String PLAN_DELETE_SUCCESS = "用药计划删除成功";
public static final String PLAN_NOT_EXIST = "用药计划不存在";
public static final String PLAN_ALREADY_STOPPED = "用药计划已停止";
public static final String PLAN_CONFIRM_SUCCESS = "用药确认成功";
// 健康数据相关
public static final String HEALTH_DATA_ADD_SUCCESS = "健康数据记录成功";
public static final String HEALTH_DATA_UPDATE_SUCCESS = "健康数据更新成功";
public static final String HEALTH_DATA_DELETE_SUCCESS = "健康数据删除成功";
public static final String HEALTH_DATA_NOT_EXIST = "健康数据不存在";
// 消息与公告相关
public static final String NOTIFICATION_SEND_SUCCESS = "消息发送成功";
public static final String NOTIFICATION_READ_SUCCESS = "消息已标记为已读";
public static final String NOTIFICATION_NOT_EXIST = "消息不存在";
public static final String ANNOUNCEMENT_PUBLISH_SUCCESS = "公告发布成功";
public static final String ANNOUNCEMENT_UPDATE_SUCCESS = "公告更新成功";
public static final String ANNOUNCEMENT_DELETE_SUCCESS = "公告删除成功";
public static final String ANNOUNCEMENT_NOT_EXIST = "公告不存在";
// 文件操作相关
public static final String FILE_UPLOAD_SUCCESS = "文件上传成功";
public static final String FILE_UPLOAD_FAILED = "文件上传失败";
public static final String FILE_DELETE_SUCCESS = "文件删除成功";
public static final String FILE_NOT_EXIST = "文件不存在";
public static final String FILE_FORMAT_ERROR = "文件格式错误";
public static final String FILE_SIZE_EXCEED = "文件大小超过限制";
// 数据验证相关
public static final String PARAM_IS_NULL = "参数不能为空";
public static final String PARAM_IS_INVALID = "参数无效";
public static final String DATA_NOT_FOUND = "数据不存在";
public static final String DATA_ALREADY_EXISTS = "数据已存在";
// 操作结果相关
public static final String OPERATION_SUCCESS = "操作成功";
public static final String OPERATION_FAILED = "操作失败";
public static final String SAVE_SUCCESS = "保存成功";
public static final String SAVE_FAILED = "保存失败";
public static final String DELETE_SUCCESS = "删除成功";
public static final String DELETE_FAILED = "删除失败";
public static final String UPDATE_SUCCESS = "更新成功";
public static final String UPDATE_FAILED = "更新失败";
public static final String QUERY_SUCCESS = "查询成功";
public static final String QUERY_FAILED = "查询失败";
// 系统相关
public static final String SYSTEM_ERROR = "系统错误";
public static final String NETWORK_ERROR = "网络错误";
public static final String DATABASE_ERROR = "数据库错误";
public static final String SERVICE_UNAVAILABLE = "服务不可用";
public static final String REQUEST_TIMEOUT = "请求超时";
// 权限相关
public static final String PERMISSION_DENIED = "权限不足";
public static final String ROLE_NOT_EXIST = "角色不存在";
public static final String NEED_ADMIN_ROLE = "需要管理员权限";
public static final String NEED_FAMILY_ROLE = "需要家属权限";
// 导出相关
public static final String EXPORT_SUCCESS = "导出成功";
public static final String EXPORT_FAILED = "导出失败";
// 提醒相关
public static final String REMINDER_SENT = "提醒已发送";
public static final String REMINDER_MISSED = "用药漏服提醒";
public static final String REMINDER_CONFIRMED = "用药已确认";
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/constant/MessageConstant.java | Java | unknown | 6,180 |
package com.rahms.common.context;
public class UserContext {
private static final ThreadLocal<Long> CURRENT_USER_ID = new ThreadLocal<>();
public static void setCurrentUserId(Long userId) {
CURRENT_USER_ID.set(userId);
}
public static Long getCurrentUserId() {
return CURRENT_USER_ID.get();
}
public static void clear() {
CURRENT_USER_ID.remove();
}
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/context/UserContext.java | Java | unknown | 411 |
package com.rahms.common.enumeration;
public enum AccountStatus {
disabled(0),
enabled(1);
private final int code;
AccountStatus(int code) {
this.code = code;
}
public int getCode() {
return code;
}
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/enumeration/AccountStatus.java | Java | unknown | 251 |
package com.rahms.common.enumeration;
public enum MessageType {
reminder,
warning,
system
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/enumeration/MessageType.java | Java | unknown | 107 |
package com.rahms.common.enumeration;
public enum UserRole {
admin,
family,
elder
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/enumeration/UserRole.java | Java | unknown | 99 |
package com.rahms.common.handler;
public class ApiException extends RuntimeException {
private int code = 0;
public ApiException(String message) {
super(message);
}
public ApiException(int code, String message) {
super(message);
this.code = code;
}
public int getCode() {
return code;
}
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/handler/ApiException.java | Java | unknown | 355 |
package com.rahms.common.json;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JacksonConfig {
@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
return mapper;
}
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/json/JacksonConfig.java | Java | unknown | 491 |
package com.rahms.common.properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "rahms.jwt")
public class JwtProperties {
private String secret;
private Long ttlSeconds;
private String issuer;
public String getSecret() {
return secret;
}
public void setSecret(String secret) {
this.secret = secret;
}
public Long getTtlSeconds() {
return ttlSeconds;
}
public void setTtlSeconds(Long ttlSeconds) {
this.ttlSeconds = ttlSeconds;
}
public String getIssuer() {
return issuer;
}
public void setIssuer(String issuer) {
this.issuer = issuer;
}
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/properties/JwtProperties.java | Java | unknown | 785 |
package com.rahms.common.result;
import java.util.List;
public class PageResult<T> {
private long total;
private List<T> records;
public PageResult() {}
public PageResult(long total, List<T> records) {
this.total = total;
this.records = records;
}
public long getTotal() {
return total;
}
public void setTotal(long total) {
this.total = total;
}
public List<T> getRecords() {
return records;
}
public void setRecords(List<T> records) {
this.records = records;
}
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/result/PageResult.java | Java | unknown | 574 |
package com.rahms.common.result;
import java.util.HashMap;
import java.util.Map;
/**
* 全局统一返回结果类
*/
public class R<T> {
private Integer code; // 编码：1成功，0和其它数字为失败
private String msg; // 错误信息
private T data; // 数据
private Map<String, Object> map = new HashMap<>(); // 动态数据
public static <T> R<T> success(T object) {
R<T> r = new R<T>();
r.data = object;
r.code = 1;
return r;
}
public static <T> R<T> error(String msg) {
R r = new R();
r.msg = msg;
r.code = 0;
return r;
}
public R<T> add(String key, Object value) {
this.map.put(key, value);
return this;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Map<String, Object> getMap() {
return map;
}
public void setMap(Map<String, Object> map) {
this.map = map;
}
} | 2401_83195498/community_elder | common/src/main/java/com/rahms/common/result/R.java | Java | unknown | 1,340 |
package com.rahms.common.utils;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
public class JwtUtil {
public static String generateToken(String subject, String issuer, String secret, long ttlSeconds) {
long nowMillis = System.currentTimeMillis();
Date now = new Date(nowMillis);
Date exp = new Date(nowMillis + ttlSeconds * 1000);
return Jwts.builder()
.setSubject(subject)
.setIssuer(issuer)
.setIssuedAt(now)
.setExpiration(exp)
.signWith(SignatureAlgorithm.HS256, secret)
.compact();
}
public static Claims parseToken(String token, String secret) {
return Jwts.parser()
.setSigningKey(secret)
.parseClaimsJws(token)
.getBody();
}
}
| 2401_83195498/community_elder | common/src/main/java/com/rahms/common/utils/JwtUtil.java | Java | unknown | 920 |
package com.rahms.pojo.dto;
import io.swagger.v3.oas.annotations.media.Schema;
@Schema(description = "用户登录请求参数")
public class AuthLoginDTO {
@Schema(description = "用户名", example = "admin", required = true)
private String username;
@Schema(description = "密码", example = "123456", required = true)
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
| 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/dto/AuthLoginDTO.java | Java | unknown | 683 |
package com.rahms.pojo.dto;
import io.swagger.v3.oas.annotations.media.Schema;
@Schema(description = "用户注册请求参数")
public class AuthRegisterDTO {
@Schema(description = "用户名", example = "admin", required = true)
private String username;
@Schema(description = "密码", example = "123456", required = true)
private String password;
@Schema(description = "真实姓名", example = "张三", required = true)
private String realName;
@Schema(description = "手机号", example = "13800138000", required = true)
private String phone;
@Schema(description = "用户角色", example = "family", allowableValues = {"family", "admin"}, required = true)
private String role; // family or admin
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
}
| 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/dto/AuthRegisterDTO.java | Java | unknown | 1,498 |
package com.rahms.pojo.dto;
import io.swagger.v3.oas.annotations.media.Schema;
@Schema(description = "分页查询请求参数")
public class PageQueryDTO {
@Schema(description = "页码", example = "1", defaultValue = "1")
private Integer page; // 页码
@Schema(description = "每页大小", example = "10", defaultValue = "10")
private Integer size; // 每页大小
@Schema(description = "关键词", example = "张三")
private String keyword; // 关键词（用户名、药品名等）
@Schema(description = "用户角色过滤", example = "family", allowableValues = {"family", "admin", "elder"})
private String role; // 用户角色过滤
@Schema(description = "通用类型过滤", example = "blood_pressure")
private String type; // 通用类型过滤（如数据类型、消息类型）
@Schema(description = "已读状态", example = "0", allowableValues = {"0", "1"})
private Integer isRead; // 已读状态
@Schema(description = "状态字段", example = "1", allowableValues = {"0", "1"})
private Integer status; // 状态字段
public Integer getPage() {
return page;
}
public void setPage(Integer page) {
this.page = page;
}
public Integer getSize() {
return size;
}
public void setSize(Integer size) {
this.size = size;
}
public String getKeyword() {
return keyword;
}
public void setKeyword(String keyword) {
this.keyword = keyword;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public Integer getIsRead() {
return isRead;
}
public void setIsRead(Integer isRead) {
this.isRead = isRead;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
}
| 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/dto/PageQueryDTO.java | Java | unknown | 2,096 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 社区公告实体类，对应community_announcement表
*/
@Data
@TableName("community_announcement")
public class CommunityAnnouncement {
@TableId(type = IdType.AUTO)
private Long announceId;
private String title; // 公告标题
private String content; // 公告详细内容（支持富文本）
private Long publisherId; // 发布者用户ID (关联 sys_user.user_id)
private LocalDateTime publishTime; // 发布时间
private Integer status; // 状态 (0: 草稿, 1: 已发布, 2: 已撤销)
private LocalDateTime startTime; // 公告开始生效时间
private LocalDateTime endTime; // 公告结束生效时间
private LocalDateTime createTime; // 创建时间
// 可选字段（根据服务实现使用到的字段补齐）
private String category; // 分类
private Integer viewCount; // 阅读量
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/CommunityAnnouncement.java | Java | unknown | 1,155 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDate;
/**
* 用药计划实体类，对应drug_plan表
*/
@Data
@TableName("drug_plan")
public class DrugPlan {
@TableId(type = IdType.AUTO)
private Long planId;
private Long elderlyId; // 关联老人ID
private Long medId; // 关联药品ID
private String dosage; // 单次剂量（如：1片）
private Integer timesPerDay; // 每日次数
private String specificTimes; // 具体时间点（JSON字符串存储，如：["08:00", "12:00", "18:00"]）
private LocalDate startDate; // 计划开始日期
private LocalDate endDate; // 计划结束日期（null则为长期）
private Integer status; // 状态 (0:已停止, 1:生效中)
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/DrugPlan.java | Java | unknown | 956 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDate;
/**
* 老人信息实体类，对应elderly_info表
*/
@Data
@TableName("elderly_info")
public class ElderlyInfo {
@TableId(type = IdType.AUTO)
private Long elderlyId;
private Long userId; // 关联用户ID（家属账户）
private String name; // 老人姓名
private Integer gender; // 性别 (0:女, 1:男)
private LocalDate birthDate; // 出生日期
private String phone; // 联系方式
private String address; // 住址
private String medicalHistory; // 病史
private String allergyHistory; // 过敏史
private String avatar; // 老人头像
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/ElderlyInfo.java | Java | unknown | 888 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 健康数据实体类，对应health_data表
*/
@Data
@TableName("health_data")
public class HealthData {
@TableId(type = IdType.AUTO)
private Long dataId;
private Long elderlyId; // 关联老人ID
private Long recordedBy; // 记录人用户ID
private String dataType; // 数据类型 (blood_pressure, blood_sugar, ...)
private String dataValue; // 数据值（如血压"120/80"，血糖"5.6"）
private String unit; // 单位
private LocalDateTime recordTime; // 记录时间
private String notes; // 备注
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/HealthData.java | Java | unknown | 837 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* 药品实体类，对应medication表
*/
@Data
@TableName("medication")
public class Medication {
@TableId(type = IdType.AUTO)
private Long medId;
private Long userId; // 关联用户ID（创建者）
private String medName; // 药品通用名
private String brand; // 品牌/商品名
private String dosage; // 规格（如：25mg*30片）
private String usage; // 用法用量（文字描述）
private String indication; // 适应证
private String precautions; // 注意事项
private String imageUrl; // 药品图片
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/Medication.java | Java | unknown | 826 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 用药提醒记录实体类，对应medication_reminder_log表
*/
@Data
@TableName("medication_reminder_log")
public class MedicationReminderLog {
@TableId(type = IdType.AUTO)
private Long logId;
private Long planId; // 关联计划ID
private Long elderlyId; // 关联老人ID
private LocalDateTime scheduledTime; // 计划服药时间
private LocalDateTime remindTime; // 实际提醒时间
private Integer status; // 状态 (0:待提醒, 1:已提醒, 2:已确认, 3:已漏服)
private LocalDateTime confirmTime; // 确认时间
private Long confirmedBy; // 确认人用户ID
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/MedicationReminderLog.java | Java | unknown | 905 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 消息通知实体类，对应notification表
*/
@Data
@TableName("notification")
public class Notification {
@TableId(type = IdType.AUTO)
private Long notiId;
private Long userId; // 接收用户ID
private String title; // 标题
private String content; // 内容
private String notiType; // 类型（reminder, warning, announcement）
private Integer isRead; // 是否已读 (0:未读, 1:已读)
private LocalDateTime createTime; // 创建时间
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/Notification.java | Java | unknown | 767 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 系统消息实体类，对应system_message表
*/
@Data
@TableName("system_message")
public class SystemMessage {
@TableId(type = IdType.AUTO)
private Long messageId;
private String title; // 消息标题（如：用药提醒、漏服预警）
private String content; // 消息内容
private String msgType; // 消息类型 (reminder: 提醒, warning: 预警, system: 系统通知)
private Long recipientId; // 接收者用户ID (关联 sys_user.user_id)
private Long relatedElderlyId; // 关联老人ID (关联 elderly_info.elderly_id, 可为空)
private Long relatedLogId; // 关联用药记录ID (关联 medication_reminder_log.log_id, 可为空)
private Integer isRead; // 是否已读 (0: 未读, 1: 已读)
private LocalDateTime sendTime; // 消息发送时间
private LocalDateTime expireTime; // 消息过期时间
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/SystemMessage.java | Java | unknown | 1,170 |
package com.rahms.pojo.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 用户实体类，对应sys_user表
*/
@Data
@TableName("sys_user")
public class User {
@TableId(type = IdType.AUTO)
private Long userId;
private String username; // 用户名（登录用）
private String password; // 加密后的密码
private String realName; // 真实姓名
private String phone; // 手机号（接收短信）
private String role; // 角色（admin, family, elder）
private String avatar; // 头像URL
private Integer status; // 账户状态 (0:禁用, 1:正常)
private LocalDateTime createTime; // 创建时间
} | 2401_83195498/community_elder | pojo/src/main/java/com/rahms/pojo/entity/User.java | Java | unknown | 873 |
package com.rahms.server;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 社区老年人用药提醒与健康管理系统启动类
*/
@SpringBootApplication
public class RAHMSApplication {
public static void main(String[] args) {
SpringApplication.run(RAHMSApplication.class, args);
System.out.println("=================================");
System.out.println("社区老年人用药提醒与健康管理系统启动成功！");
System.out.println("API文档地址：http://localhost:8080/doc.html");
System.out.println("Swagger UI：http://localhost:8080/swagger-ui.html");
System.out.println("OpenAPI JSON：http://localhost:8080/v3/api-docs");
System.out.println("=================================");
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/RAHMSApplication.java | Java | unknown | 854 |
package com.rahms.server;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ServerApplication {
public static void main(String[] args) {
SpringApplication.run(ServerApplication.class, args);
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/ServerApplication.java | Java | unknown | 321 |
package com.rahms.server.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
@Configuration
public class CorsConfig {
@Bean
public CorsFilter corsFilter() {
CorsConfiguration config = new CorsConfiguration();
config.addAllowedOriginPattern("*");
config.addAllowedHeader("*");
config.addAllowedMethod("*");
config.setAllowCredentials(true);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", config);
return new CorsFilter(source);
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/config/CorsConfig.java | Java | unknown | 828 |
package com.rahms.server.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* Knife4j配置类
*/
@Configuration
public class Knife4jConfig {
// Knife4j配置通过application.properties进行配置
// 不需要额外的Bean配置
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/config/Knife4jConfig.java | Java | unknown | 320 |
package com.rahms.server.config;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import com.rahms.common.constant.AutoFillConstant;
import com.rahms.common.context.UserContext;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.LocalDateTime;
/**
* MyBatis-Plus 配置类
*/
@Configuration
public class MybatisPlusConfig {
/**
* 自动填充处理器
*/
@Bean
public MetaObjectHandler metaObjectHandler() {
return new MetaObjectHandler() {
@Override
public void insertFill(MetaObject metaObject) {
// 自动填充创建时间
this.strictInsertFill(metaObject, AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class, LocalDateTime.now());
// 自动填充创建用户
Long currentUserId = UserContext.getCurrentUserId();
if (currentUserId != null) {
this.strictInsertFill(metaObject, AutoFillConstant.SET_CREATE_USER, Long.class, currentUserId);
}
}
@Override
public void updateFill(MetaObject metaObject) {
// 自动填充更新时间
this.strictUpdateFill(metaObject, AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class, LocalDateTime.now());
// 自动填充更新用户
Long currentUserId = UserContext.getCurrentUserId();
if (currentUserId != null) {
this.strictUpdateFill(metaObject, AutoFillConstant.SET_UPDATE_USER, Long.class, currentUserId);
}
}
};
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/config/MybatisPlusConfig.java | Java | unknown | 1,758 |
package com.rahms.server.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
/**
* Redis配置类
*/
@Configuration
@EnableCaching
public class RedisConfig {
/**
* RedisTemplate配置
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
// 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(mapper);
// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(serializer);
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(serializer);
template.afterPropertiesSet();
return template;
}
/**
* 缓存管理器配置
*/
@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
// 配置序列化
Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(mapper);
// 配置缓存
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofMinutes(30)) // 默认30分钟过期
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer))
.disableCachingNullValues();
return RedisCacheManager.builder(connectionFactory)
.cacheDefaults(config)
.build();
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/config/RedisConfig.java | Java | unknown | 3,417 |
package com.rahms.server.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
/**
* Redis健康检查配置
*/
@Component
public class RedisHealthCheck implements CommandLineRunner {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Override
public void run(String... args) throws Exception {
try {
// 测试Redis连接
redisTemplate.opsForValue().set("health_check", "ok");
String result = (String) redisTemplate.opsForValue().get("health_check");
if ("ok".equals(result)) {
System.out.println("✅ Redis连接成功！");
redisTemplate.delete("health_check");
} else {
System.err.println("❌ Redis连接失败！");
}
} catch (Exception e) {
System.err.println("❌ Redis连接异常: " + e.getMessage());
System.err.println("请确保Redis服务已启动，配置信息：");
System.err.println("- Host: localhost");
System.err.println("- Port: 6379");
System.err.println("- Database: 0");
}
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/config/RedisHealthCheck.java | Java | unknown | 1,321 |
package com.rahms.server.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http.csrf(csrf -> csrf.disable())
.authorizeHttpRequests(auth -> auth
.requestMatchers("/auth/**").permitAll()
.anyRequest().permitAll()
)
.httpBasic(Customizer.withDefaults());
return http.build();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/config/SecurityConfig.java | Java | unknown | 1,033 |
package com.rahms.server.controller;
import com.rahms.common.result.R;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**
* API文档示例控制器
*/
@RestController
@RequestMapping("/api-docs")
@Tag(name = "API文档", description = "API文档相关接口")
public class ApiDocumentationController {
@GetMapping("/info")
@Operation(summary = "获取API信息", description = "获取API文档的基本信息")
public R<Map<String, Object>> getApiInfo() {
Map<String, Object> info = new HashMap<>();
info.put("title", "社区老年人用药提醒与健康管理系统 API");
info.put("version", "1.0.0");
info.put("description", "基于Spring Boot的社区老年人用药提醒与健康管理系统");
info.put("contact", Map.of(
"name", "RAHMS开发团队",
"email", "rahms@example.com",
"url", "https://github.com/rahms/community-elderly-medication-management"
));
info.put("license", Map.of(
"name", "MIT License",
"url", "https://opensource.org/licenses/MIT"
));
info.put("servers", new String[]{
"http://localhost:8080 (开发环境)",
"https://api.rahms.com (生产环境)"
});
return R.success(info);
}
@GetMapping("/endpoints")
@Operation(summary = "获取API端点列表", description = "获取所有可用的API端点")
public R<Map<String, String[]>> getApiEndpoints() {
Map<String, String[]> endpoints = new HashMap<>();
endpoints.put("认证管理", new String[]{
"POST /auth/register - 用户注册",
"POST /auth/login - 用户登录"
});
endpoints.put("用户管理", new String[]{
"GET /user/me - 获取当前用户信息",
"PUT /user/me - 更新用户信息",
"POST /user/change-password - 修改密码",
"GET /user/list - 获取用户列表"
});
endpoints.put("老人信息管理", new String[]{
"GET /elderly - 获取老人列表",
"GET /elderly/detail - 获取老人详情",
"POST /elderly/add - 添加老人信息",
"POST /elderly/update - 更新老人信息",
"POST /elderly/delete - 删除老人信息"
});
endpoints.put("药品管理", new String[]{
"GET /medications - 获取药品列表",
"GET /medications/detail - 获取药品详情",
"POST /medications/add - 添加药品",
"POST /medications/update - 更新药品",
"POST /medications/delete - 删除药品"
});
endpoints.put("用药计划管理", new String[]{
"GET /drug-plans - 获取用药计划列表",
"GET /drug-plans/detail - 获取用药计划详情",
"POST /drug-plans/add - 添加用药计划",
"POST /drug-plans/update - 更新用药计划",
"POST /drug-plans/delete - 删除用药计划"
});
endpoints.put("健康数据管理", new String[]{
"GET /health-data/by-type - 根据类型获取健康数据",
"GET /health-data/by-date - 根据日期范围获取健康数据",
"GET /health-data/statistics - 获取健康数据统计",
"POST /health-data/add - 添加健康数据",
"POST /health-data/update - 更新健康数据"
});
endpoints.put("缓存管理", new String[]{
"POST /cache/clear-all - 清除所有缓存",
"POST /cache/clear-user - 清除用户缓存",
"POST /cache/clear-medication - 清除药品缓存",
"GET /cache/info - 获取缓存信息",
"POST /cache/set - 设置缓存",
"POST /cache/delete - 删除缓存"
});
endpoints.put("常量管理", new String[]{
"GET /constants/messages - 获取消息常量",
"GET /constants/cache - 获取缓存常量",
"GET /constants/jwt-claims - 获取JWT声明常量",
"GET /constants/auto-fill - 获取自动填充常量",
"GET /constants/all - 获取所有常量"
});
return R.success(endpoints);
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/ApiDocumentationController.java | Java | unknown | 4,704 |
package com.rahms.server.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.rahms.common.constant.MessageConstant;
import com.rahms.common.result.R;
import com.rahms.pojo.dto.AuthLoginDTO;
import com.rahms.pojo.dto.AuthRegisterDTO;
import com.rahms.pojo.entity.User;
import com.rahms.server.service.UserService;
import com.rahms.server.utils.JwtTokenUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;
@RestController
@RequestMapping("/auth")
@Tag(name = "认证管理", description = "用户注册、登录、退出等认证相关接口")
public class AuthController {
@Autowired
private UserService userService;
@Autowired(required = false)
private PasswordEncoder passwordEncoder;
@Autowired
private JwtTokenUtil jwtTokenUtil;
@PostMapping("/register")
@Operation(summary = "用户注册", description = "新用户注册接口，支持家属和管理员注册")
public R<User> register(@RequestBody AuthRegisterDTO dto) {
// 使用缓存查询用户是否存在
User existingUser = userService.getUserByUsername(dto.getUsername());
if (existingUser != null) {
return R.error(MessageConstant.USERNAME_EXISTS);
}
User user = new User();
user.setUsername(dto.getUsername());
user.setPassword(passwordEncoder != null ? passwordEncoder.encode(dto.getPassword()) : dto.getPassword());
user.setRealName(dto.getRealName());
user.setPhone(dto.getPhone());
user.setRole(dto.getRole());
user.setStatus(1);
boolean saved = userService.save(user);
return saved ? R.success(user).add("message", MessageConstant.REGISTER_SUCCESS) : R.error(MessageConstant.SAVE_FAILED);
}
@PostMapping("/login")
@Operation(summary = "用户登录", description = "用户登录接口，返回用户信息和JWT Token")
public R<Map<String, Object>> login(@RequestBody AuthLoginDTO dto) {
// 使用缓存查询用户
User user = userService.getUserByUsername(dto.getUsername());
if (user == null) {
return R.error(MessageConstant.ACCOUNT_NOT_FOUND);
}
boolean matches = passwordEncoder != null ? passwordEncoder.matches(dto.getPassword(), user.getPassword()) : dto.getPassword().equals(user.getPassword());
if (!matches) {
return R.error(MessageConstant.PASSWORD_ERROR);
}
// 生成JWT令牌
String token = jwtTokenUtil.generateToken(user.getUserId(), user.getUsername(), user.getPhone(), user.getRealName());
Map<String, Object> result = new HashMap<>();
result.put("user", user);
result.put("token", token);
return R.success(result).add("message", MessageConstant.LOGIN_SUCCESS);
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/AuthController.java | Java | unknown | 3,165 |
package com.rahms.server.controller;
import com.rahms.common.constant.CacheConstant;
import com.rahms.common.result.R;
import com.rahms.server.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* 缓存管理控制器
*/
@RestController
@RequestMapping("/cache")
public class CacheController {
@Autowired
private RedisUtil redisUtil;
/**
* 清除所有缓存
*/
@PostMapping("/clear-all")
public R<Boolean> clearAllCache() {
try {
// 清除所有缓存
redisUtil.delete("*");
return R.success(true).add("message", "所有缓存已清除");
} catch (Exception e) {
return R.error("清除缓存失败: " + e.getMessage());
}
}
/**
* 清除用户相关缓存
*/
@PostMapping("/clear-user")
public R<Boolean> clearUserCache(@RequestParam(required = false) Long userId) {
try {
if (userId != null) {
// 清除特定用户缓存
redisUtil.delete(CacheConstant.USER_INFO_CACHE + userId);
redisUtil.delete(CacheConstant.USER_LIST_CACHE + "*");
} else {
// 清除所有用户缓存
redisUtil.delete(CacheConstant.USER_CACHE_PREFIX + "*");
}
return R.success(true).add("message", "用户缓存已清除");
} catch (Exception e) {
return R.error("清除用户缓存失败: " + e.getMessage());
}
}
/**
* 清除药品相关缓存
*/
@PostMapping("/clear-medication")
public R<Boolean> clearMedicationCache() {
try {
redisUtil.delete(CacheConstant.MEDICATION_CACHE_PREFIX + "*");
return R.success(true).add("message", "药品缓存已清除");
} catch (Exception e) {
return R.error("清除药品缓存失败: " + e.getMessage());
}
}
/**
* 清除健康数据相关缓存
*/
@PostMapping("/clear-health-data")
public R<Boolean> clearHealthDataCache() {
try {
redisUtil.delete(CacheConstant.HEALTH_DATA_CACHE_PREFIX + "*");
return R.success(true).add("message", "健康数据缓存已清除");
} catch (Exception e) {
return R.error("清除健康数据缓存失败: " + e.getMessage());
}
}
/**
* 获取缓存信息
*/
@GetMapping("/info")
public R<Object> getCacheInfo(@RequestParam String key) {
try {
Object value = redisUtil.get(key);
if (value != null) {
return R.success(value).add("message", "缓存信息获取成功");
} else {
return R.error("缓存不存在");
}
} catch (Exception e) {
return R.error("获取缓存信息失败: " + e.getMessage());
}
}
/**
* 设置缓存
*/
@PostMapping("/set")
public R<Boolean> setCache(@RequestParam String key,
@RequestParam String value,
@RequestParam(defaultValue = "1800") long timeout) {
try {
redisUtil.set(key, value, timeout, java.util.concurrent.TimeUnit.SECONDS);
return R.success(true).add("message", "缓存设置成功");
} catch (Exception e) {
return R.error("设置缓存失败: " + e.getMessage());
}
}
/**
* 删除缓存
*/
@PostMapping("/delete")
public R<Boolean> deleteCache(@RequestParam String key) {
try {
boolean result = redisUtil.delete(key);
return result ? R.success(true).add("message", "缓存删除成功") : R.error("缓存不存在");
} catch (Exception e) {
return R.error("删除缓存失败: " + e.getMessage());
}
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/CacheController.java | Java | unknown | 3,931 |
package com.rahms.server.controller;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.CommunityAnnouncement;
import com.rahms.server.service.CommunityAnnouncementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 社区公告控制器
*/
@RestController
@RequestMapping("/announcement")
public class CommunityAnnouncementController {
@Autowired
private CommunityAnnouncementService communityAnnouncementService;
/**
* 获取最新的公告列表
*/
@GetMapping("/latest")
public R<List<CommunityAnnouncement>> getLatestAnnouncements(@RequestParam(required = false, defaultValue = "10") Integer limit) {
List<CommunityAnnouncement> list = communityAnnouncementService.getLatestAnnouncements(limit);
return R.success(list);
}
/**
* 根据分类获取公告列表
*/
@GetMapping("/by-category")
public R<List<CommunityAnnouncement>> getAnnouncementsByCategory(@RequestParam String category,
@RequestParam(required = false, defaultValue = "10") Integer limit) {
List<CommunityAnnouncement> list = communityAnnouncementService.getAnnouncementsByCategory(category, limit);
return R.success(list);
}
/**
* 获取公告详情并增加阅读量
*/
@GetMapping("/detail")
public R<CommunityAnnouncement> getAnnouncementDetail(@RequestParam Long announcementId) {
// 增加阅读量
communityAnnouncementService.increaseViewCount(announcementId);
// 获取公告详情
CommunityAnnouncement announcement = communityAnnouncementService.getById(announcementId);
return announcement != null ? R.success(announcement) : R.error("公告不存在");
}
/**
* 增加公告阅读量
*/
@PostMapping("/increase-view")
public R<Boolean> increaseViewCount(@RequestParam Long announcementId) {
boolean result = communityAnnouncementService.increaseViewCount(announcementId);
return result ? R.success(true) : R.error("操作失败");
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/CommunityAnnouncementController.java | Java | unknown | 2,223 |
package com.rahms.server.controller;
import com.rahms.common.result.R;
import com.rahms.server.service.ConstantService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
/**
* 常量管理控制器
*/
@RestController
@RequestMapping("/constants")
public class ConstantController {
@Autowired
private ConstantService constantService;
/**
* 获取所有消息常量
*/
@GetMapping("/messages")
public R<Map<String, String>> getAllMessageConstants() {
Map<String, String> messages = constantService.getAllMessageConstants();
return R.success(messages).add("message", "消息常量获取成功");
}
/**
* 获取所有缓存常量
*/
@GetMapping("/cache")
public R<Map<String, Object>> getAllCacheConstants() {
Map<String, Object> cacheConstants = constantService.getAllCacheConstants();
return R.success(cacheConstants).add("message", "缓存常量获取成功");
}
/**
* 获取所有JWT声明常量
*/
@GetMapping("/jwt-claims")
public R<Map<String, String>> getAllJwtClaimsConstants() {
Map<String, String> jwtClaims = constantService.getAllJwtClaimsConstants();
return R.success(jwtClaims).add("message", "JWT声明常量获取成功");
}
/**
* 获取所有自动填充常量
*/
@GetMapping("/auto-fill")
public R<Map<String, String>> getAllAutoFillConstants() {
Map<String, String> autoFill = constantService.getAllAutoFillConstants();
return R.success(autoFill).add("message", "自动填充常量获取成功");
}
/**
* 获取所有常量
*/
@GetMapping("/all")
public R<Map<String, Object>> getAllConstants() {
Map<String, Object> allConstants = constantService.getAllConstants();
return R.success(allConstants).add("message", "所有常量获取成功");
}
/**
* 根据类型获取常量
*/
@GetMapping("/by-type")
public R<Object> getConstantsByType(@RequestParam String type) {
switch (type.toLowerCase()) {
case "messages":
return R.success(constantService.getAllMessageConstants());
case "cache":
return R.success(constantService.getAllCacheConstants());
case "jwt-claims":
return R.success(constantService.getAllJwtClaimsConstants());
case "auto-fill":
return R.success(constantService.getAllAutoFillConstants());
case "all":
return R.success(constantService.getAllConstants());
default:
return R.error("不支持的常量类型: " + type);
}
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/ConstantController.java | Java | unknown | 2,780 |
package com.rahms.server.controller;
import com.rahms.common.constant.MessageConstant;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.DrugPlan;
import com.rahms.server.service.DrugPlanService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 用药计划控制器
*/
@RestController
@RequestMapping("/drug-plan")
public class DrugPlanController {
@Autowired
private DrugPlanService drugPlanService;
/**
* 获取老人的用药计划列表
*/
@GetMapping("/list")
public R<List<DrugPlan>> getDrugPlansByElderlyId(@RequestParam Long elderlyId) {
List<DrugPlan> list = drugPlanService.getDrugPlansByElderlyId(elderlyId);
return R.success(list);
}
/**
* 获取生效中的用药计划
*/
@GetMapping("/active")
public R<List<DrugPlan>> getActiveDrugPlans() {
List<DrugPlan> list = drugPlanService.getActiveDrugPlans();
return R.success(list);
}
/**
* 获取用药计划详情
*/
@GetMapping("/detail")
public R<DrugPlan> getDrugPlanDetail(@RequestParam Long planId) {
DrugPlan drugPlan = drugPlanService.getById(planId);
return drugPlan != null ? R.success(drugPlan) : R.error(MessageConstant.PLAN_NOT_EXIST);
}
/**
* 添加用药计划
*/
@PostMapping("/add")
public R<Boolean> addDrugPlan(@RequestBody DrugPlan drugPlan) {
boolean result = drugPlanService.save(drugPlan);
return result ? R.success(true).add("message", MessageConstant.PLAN_ADD_SUCCESS) : R.error(MessageConstant.SAVE_FAILED);
}
/**
* 更新用药计划
*/
@PostMapping("/update")
public R<Boolean> updateDrugPlan(@RequestBody DrugPlan drugPlan) {
boolean result = drugPlanService.updateById(drugPlan);
return result ? R.success(true).add("message", MessageConstant.PLAN_UPDATE_SUCCESS) : R.error(MessageConstant.UPDATE_FAILED);
}
/**
* 删除用药计划
*/
@PostMapping("/delete")
public R<Boolean> deleteDrugPlan(@RequestParam Long planId) {
boolean result = drugPlanService.removeById(planId);
return result ? R.success(true).add("message", MessageConstant.PLAN_DELETE_SUCCESS) : R.error(MessageConstant.DELETE_FAILED);
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/DrugPlanController.java | Java | unknown | 2,400 |
package com.rahms.server.controller;
import com.rahms.common.constant.MessageConstant;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.ElderlyInfo;
import com.rahms.server.service.ElderlyInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 老人信息控制器
*/
@RestController
@RequestMapping("/elderly")
public class ElderlyInfoController {
@Autowired
private ElderlyInfoService elderlyInfoService;
/**
* 获取用户关联的老人列表
*/
@GetMapping("/list")
public R<List<ElderlyInfo>> getElderlyListByUserId(@RequestParam Long userId) {
List<ElderlyInfo> list = elderlyInfoService.getElderlyListByUserId(userId);
return R.success(list);
}
/**
* 获取老人详情
*/
@GetMapping("/detail")
public R<ElderlyInfo> getElderlyDetail(@RequestParam Long elderlyId) {
ElderlyInfo elderlyInfo = elderlyInfoService.getById(elderlyId);
return elderlyInfo != null ? R.success(elderlyInfo) : R.error(MessageConstant.ELDERLY_NOT_EXIST);
}
/**
* 添加老人信息
*/
@PostMapping("/add")
public R<Boolean> addElderlyInfo(@RequestBody ElderlyInfo elderlyInfo) {
boolean result = elderlyInfoService.save(elderlyInfo);
return result ? R.success(true).add("message", MessageConstant.ELDERLY_ADD_SUCCESS) : R.error(MessageConstant.SAVE_FAILED);
}
/**
* 更新老人信息
*/
@PostMapping("/update")
public R<Boolean> updateElderlyInfo(@RequestBody ElderlyInfo elderlyInfo) {
boolean result = elderlyInfoService.updateById(elderlyInfo);
return result ? R.success(true).add("message", MessageConstant.ELDERLY_UPDATE_SUCCESS) : R.error(MessageConstant.UPDATE_FAILED);
}
/**
* 删除老人信息
*/
@PostMapping("/delete")
public R<Boolean> deleteElderlyInfo(@RequestParam Long elderlyId) {
boolean result = elderlyInfoService.removeById(elderlyId);
return result ? R.success(true).add("message", MessageConstant.ELDERLY_DELETE_SUCCESS) : R.error(MessageConstant.DELETE_FAILED);
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/ElderlyInfoController.java | Java | unknown | 2,241 |
package com.rahms.server.controller;
import com.rahms.common.constant.MessageConstant;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.HealthData;
import com.rahms.server.service.HealthDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
/**
* 健康数据控制器
*/
@RestController
@RequestMapping("/health-data")
public class HealthDataController {
@Autowired
private HealthDataService healthDataService;
/**
* 根据老人ID和数据类型获取健康数据
*/
@GetMapping("/by-type")
public R<List<HealthData>> getHealthDataByElderlyIdAndType(@RequestParam Long elderlyId,
@RequestParam String dataType) {
List<HealthData> list = healthDataService.getHealthDataByElderlyIdAndType(elderlyId, dataType);
return R.success(list);
}
/**
* 根据日期范围获取健康数据
*/
@GetMapping("/by-date")
public R<List<HealthData>> getHealthDataByDateRange(@RequestParam Long elderlyId,
@RequestParam(required = false) String dataType,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime startDate,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime endDate) {
List<HealthData> list = healthDataService.getHealthDataByDateRange(elderlyId, dataType, startDate, endDate);
return R.success(list);
}
/**
* 获取健康数据统计信息
*/
@GetMapping("/statistics")
public R<Map<String, Object>> getHealthDataStatistics(@RequestParam Long elderlyId,
@RequestParam String dataType,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime startDate,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime endDate) {
Map<String, Object> statistics = healthDataService.getHealthDataStatistics(elderlyId, dataType, startDate, endDate);
return R.success(statistics);
}
/**
* 添加健康数据
*/
@PostMapping("/add")
public R<Boolean> addHealthData(@RequestBody HealthData healthData) {
boolean result = healthDataService.save(healthData);
return result ? R.success(true).add("message", MessageConstant.HEALTH_DATA_ADD_SUCCESS) : R.error(MessageConstant.SAVE_FAILED);
}
/**
* 更新健康数据
*/
@PostMapping("/update")
public R<Boolean> updateHealthData(@RequestBody HealthData healthData) {
boolean result = healthDataService.updateById(healthData);
return result ? R.success(true).add("message", MessageConstant.HEALTH_DATA_UPDATE_SUCCESS) : R.error(MessageConstant.UPDATE_FAILED);
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/HealthDataController.java | Java | unknown | 3,257 |
package com.rahms.server.controller;
import com.rahms.common.constant.MessageConstant;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.Medication;
import com.rahms.server.service.MedicationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 药品信息控制器
*/
@RestController
@RequestMapping("/medication")
public class MedicationController {
@Autowired
private MedicationService medicationService;
/**
* 获取用户的药品列表
*/
@GetMapping("/list")
public R<List<Medication>> getMedicationList(@RequestParam Long userId) {
List<Medication> list = medicationService.getMedicationListByUserId(userId);
return R.success(list);
}
/**
* 搜索药品
*/
@GetMapping("/search")
public R<List<Medication>> searchMedications(@RequestParam Long userId,
@RequestParam String keyword) {
List<Medication> list = medicationService.searchMedications(userId, keyword);
return R.success(list);
}
/**
* 获取药品详情
*/
@GetMapping("/detail")
public R<Medication> getMedicationDetail(@RequestParam Long medicationId) {
Medication medication = medicationService.getById(medicationId);
return medication != null ? R.success(medication) : R.error(MessageConstant.MEDICATION_NOT_EXIST);
}
/**
* 添加药品信息
*/
@PostMapping("/add")
public R<Boolean> addMedication(@RequestBody Medication medication) {
boolean result = medicationService.save(medication);
return result ? R.success(true).add("message", MessageConstant.MEDICATION_ADD_SUCCESS) : R.error(MessageConstant.SAVE_FAILED);
}
/**
* 更新药品信息
*/
@PostMapping("/update")
public R<Boolean> updateMedication(@RequestBody Medication medication) {
boolean result = medicationService.updateById(medication);
return result ? R.success(true).add("message", MessageConstant.MEDICATION_UPDATE_SUCCESS) : R.error(MessageConstant.UPDATE_FAILED);
}
/**
* 删除药品信息
*/
@PostMapping("/delete")
public R<Boolean> deleteMedication(@RequestParam Long medicationId) {
boolean result = medicationService.removeById(medicationId);
return result ? R.success(true).add("message", MessageConstant.MEDICATION_DELETE_SUCCESS) : R.error(MessageConstant.DELETE_FAILED);
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/MedicationController.java | Java | unknown | 2,584 |
package com.rahms.server.controller;
import com.rahms.common.constant.MessageConstant;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.MedicationReminderLog;
import com.rahms.server.service.MedicationReminderLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
/**
* 用药提醒日志控制器
*/
@RestController
@RequestMapping("/reminder-log")
public class MedicationReminderLogController {
@Autowired
private MedicationReminderLogService medicationReminderLogService;
/**
* 根据用药计划获取提醒日志
*/
@GetMapping("/by-plan")
public R<List<MedicationReminderLog>> getLogsByPlanId(@RequestParam Long planId) {
List<MedicationReminderLog> list = medicationReminderLogService.getLogsByPlanId(planId);
return R.success(list);
}
/**
* 根据老人获取提醒日志
*/
@GetMapping("/by-elderly")
public R<List<MedicationReminderLog>> getLogsByElderlyId(@RequestParam Long elderlyId) {
List<MedicationReminderLog> list = medicationReminderLogService.getLogsByElderlyId(elderlyId);
return R.success(list);
}
/**
* 根据日期范围获取提醒日志
*/
@GetMapping("/by-date")
public R<List<MedicationReminderLog>> getLogsByDateRange(@RequestParam Long elderlyId,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime startDate,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime endDate) {
List<MedicationReminderLog> list = medicationReminderLogService.getLogsByDateRange(elderlyId, startDate, endDate);
return R.success(list);
}
/**
* 确认用药
*/
@PostMapping("/confirm")
public R<Boolean> confirmMedication(@RequestParam Long logId, @RequestParam Long userId) {
boolean result = medicationReminderLogService.confirmMedication(logId, userId);
return result ? R.success(true) : R.error("确认失败");
}
/**
* 添加提醒日志
*/
@PostMapping("/add")
public R<Boolean> addReminderLog(@RequestBody MedicationReminderLog log) {
boolean result = medicationReminderLogService.save(log);
return result ? R.success(true) : R.error("添加失败");
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/MedicationReminderLogController.java | Java | unknown | 2,593 |
package com.rahms.server.controller;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.Notification;
import com.rahms.server.service.NotificationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 消息通知控制器
*/
@RestController
@RequestMapping("/notification")
public class NotificationController {
@Autowired
private NotificationService notificationService;
/**
* 获取用户的消息列表
*/
@GetMapping("/list")
public R<List<Notification>> getNotificationsByUserId(@RequestParam Long userId,
@RequestParam(required = false) String type,
@RequestParam(required = false) Integer isRead) {
List<Notification> list = notificationService.getNotificationsByUserId(userId, type, isRead);
return R.success(list);
}
/**
* 获取未读消息数量
*/
@GetMapping("/unread-count")
public R<Integer> getUnreadCountByUserId(@RequestParam Long userId) {
int count = notificationService.getUnreadCountByUserId(userId);
return R.success(count);
}
/**
* 标记消息为已读
*/
@PostMapping("/mark-read")
public R<Boolean> markAsRead(@RequestParam Long notiId) {
boolean result = notificationService.markAsRead(notiId);
return result ? R.success(true) : R.error("标记失败");
}
/**
* 批量标记消息为已读
*/
@PostMapping("/batch-mark-read")
public R<Boolean> batchMarkAsRead(@RequestBody List<Long> notiIds) {
boolean result = notificationService.batchMarkAsRead(notiIds);
return result ? R.success(true) : R.error("批量标记失败");
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/NotificationController.java | Java | unknown | 1,879 |
package com.rahms.server.controller;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.SystemMessage;
import com.rahms.server.service.SystemMessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 系统消息控制器
*/
@RestController
@RequestMapping("/system-message")
public class SystemMessageController {
@Autowired
private SystemMessageService systemMessageService;
/**
* 获取接收者的系统消息列表
*/
@GetMapping("/list")
public R<List<SystemMessage>> getMessagesByRecipientId(@RequestParam Long recipientId,
@RequestParam(required = false) String msgType,
@RequestParam(required = false) Integer isRead) {
List<SystemMessage> list = systemMessageService.getMessagesByRecipientId(recipientId, msgType, isRead);
return R.success(list);
}
/**
* 发送系统消息
*/
@PostMapping("/send")
public R<Boolean> sendSystemMessage(@RequestBody SystemMessage message) {
boolean result = systemMessageService.sendSystemMessage(message);
return result ? R.success(true) : R.error("发送失败");
}
/**
* 标记消息为已读
*/
@PostMapping("/mark-read")
public R<Boolean> markMessageAsRead(@RequestParam Long messageId) {
boolean result = systemMessageService.markMessageAsRead(messageId);
return result ? R.success(true) : R.error("标记失败");
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/SystemMessageController.java | Java | unknown | 1,648 |
package com.rahms.server.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.rahms.common.constant.MessageConstant;
import com.rahms.common.result.R;
import com.rahms.pojo.entity.User;
import com.rahms.server.service.UserService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* 用户控制器
*/
@RestController
@RequestMapping("/user")
@Tag(name = "用户管理", description = "用户信息管理相关接口")
public class UserController {
@Autowired
private UserService userService;
@Autowired(required = false)
private PasswordEncoder passwordEncoder;
/**
* 获取用户信息
*/
@GetMapping("/me")
@Operation(summary = "获取当前用户信息", description = "根据用户ID获取当前登录用户的详细信息")
public R<User> getCurrentUser(@Parameter(description = "用户ID", required = true) @RequestParam Long userId) {
User user = userService.getUserById(userId);
return user != null ? R.success(user) : R.error(MessageConstant.USER_NOT_EXIST);
}
/**
* 更新用户信息
*/
@PutMapping("/me")
public R<Boolean> updateCurrentUser(@RequestBody User user) {
boolean result = userService.updateById(user);
return result ? R.success(true).add("message", MessageConstant.USER_UPDATE_SUCCESS) : R.error(MessageConstant.UPDATE_FAILED);
}
/**
* 修改密码
*/
@PostMapping("/change-password")
public R<Boolean> changePassword(@RequestParam Long userId,
@RequestParam String oldPassword,
@RequestParam String newPassword) {
User user = userService.getById(userId);
if (user == null) {
return R.error(MessageConstant.USER_NOT_EXIST);
}
boolean matches = passwordEncoder != null ? passwordEncoder.matches(oldPassword, user.getPassword()) : oldPassword.equals(user.getPassword());
if (!matches) {
return R.error(MessageConstant.PASSWORD_ERROR);
}
user.setPassword(passwordEncoder != null ? passwordEncoder.encode(newPassword) : newPassword);
boolean result = userService.updateById(user);
return result ? R.success(true).add("message", MessageConstant.OPERATION_SUCCESS) : R.error(MessageConstant.UPDATE_FAILED);
}
/**
* 管理员：分页查询用户列表（可按角色过滤）
*/
@GetMapping("/list")
public R<java.util.List<User>> listUsers(@RequestParam Integer page,
@RequestParam Integer size,
@RequestParam(required = false) String role,
@RequestParam(required = false) String keyword) {
// 使用缓存查询用户列表
java.util.List<User> all = userService.getUserList(role, keyword);
int from = Math.max(0, (page - 1) * size);
int to = Math.min(all.size(), from + size);
java.util.List<User> pageList = from < to ? all.subList(from, to) : java.util.Collections.emptyList();
return R.success(pageList).add("total", all.size());
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/controller/UserController.java | Java | unknown | 3,524 |
package com.rahms.server.handler;
import com.rahms.common.constant.MessageConstant;
import com.rahms.common.handler.ApiException;
import com.rahms.common.result.R;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(ApiException.class)
public R<Object> handleApiException(ApiException e) {
return R.error(e.getMessage());
}
@ExceptionHandler(MethodArgumentNotValidException.class)
public R<Object> handleValidationException(MethodArgumentNotValidException e) {
String msg = e.getBindingResult().getFieldError() != null ? e.getBindingResult().getFieldError().getDefaultMessage() : MessageConstant.PARAM_IS_INVALID;
return R.error(msg);
}
@ExceptionHandler(Exception.class)
public R<Object> handleGeneralException(Exception e) {
return R.error(MessageConstant.SYSTEM_ERROR + ": " + e.getMessage());
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/handler/GlobalExceptionHandler.java | Java | unknown | 1,105 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.CommunityAnnouncement;
import org.apache.ibatis.annotations.Mapper;
/**
* 社区公告Mapper接口
*/
@Mapper
public interface CommunityAnnouncementMapper extends BaseMapper<CommunityAnnouncement> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/CommunityAnnouncementMapper.java | Java | unknown | 381 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.DrugPlan;
import org.apache.ibatis.annotations.Mapper;
/**
* 用药计划Mapper接口
*/
@Mapper
public interface DrugPlanMapper extends BaseMapper<DrugPlan> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/DrugPlanMapper.java | Java | unknown | 342 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.ElderlyInfo;
import org.apache.ibatis.annotations.Mapper;
/**
* 老人信息Mapper接口
*/
@Mapper
public interface ElderlyInfoMapper extends BaseMapper<ElderlyInfo> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/ElderlyInfoMapper.java | Java | unknown | 351 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.HealthData;
import org.apache.ibatis.annotations.Mapper;
/**
* 健康数据Mapper接口
*/
@Mapper
public interface HealthDataMapper extends BaseMapper<HealthData> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/HealthDataMapper.java | Java | unknown | 348 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.Medication;
import org.apache.ibatis.annotations.Mapper;
/**
* 药品Mapper接口
*/
@Mapper
public interface MedicationMapper extends BaseMapper<Medication> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/MedicationMapper.java | Java | unknown | 342 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.MedicationReminderLog;
import org.apache.ibatis.annotations.Mapper;
/**
* 用药提醒记录Mapper接口
*/
@Mapper
public interface MedicationReminderLogMapper extends BaseMapper<MedicationReminderLog> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/MedicationReminderLogMapper.java | Java | unknown | 387 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.Notification;
import org.apache.ibatis.annotations.Mapper;
/**
* 消息通知Mapper接口
*/
@Mapper
public interface NotificationMapper extends BaseMapper<Notification> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/NotificationMapper.java | Java | unknown | 354 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.SystemMessage;
import org.apache.ibatis.annotations.Mapper;
/**
* 系统消息Mapper接口
*/
@Mapper
public interface SystemMessageMapper extends BaseMapper<SystemMessage> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/SystemMessageMapper.java | Java | unknown | 357 |
package com.rahms.server.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.rahms.pojo.entity.User;
import org.apache.ibatis.annotations.Mapper;
/**
* 用户Mapper接口
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
// 可以根据需要添加自定义的SQL方法
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/mapper/UserMapper.java | Java | unknown | 324 |
package com.rahms.server.service;
import com.rahms.common.constant.CacheConstant;
import com.rahms.server.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
/**
* 缓存服务类
*/
@Service
public class CacheService {
@Autowired
private RedisUtil redisUtil;
/**
* 缓存用户信息
*/
public void cacheUserInfo(Long userId, Object userInfo) {
String key = CacheConstant.USER_INFO_CACHE + userId;
redisUtil.set(key, userInfo, CacheConstant.CACHE_EXPIRE_MEDIUM, TimeUnit.SECONDS);
}
/**
* 获取用户信息缓存
*/
public Object getUserInfoCache(Long userId) {
String key = CacheConstant.USER_INFO_CACHE + userId;
return redisUtil.get(key);
}
/**
* 缓存用户列表
*/
public void cacheUserList(String role, String keyword, Object userList) {
String key = CacheConstant.USER_LIST_CACHE + role + ":" + keyword;
redisUtil.set(key, userList, CacheConstant.CACHE_EXPIRE_MEDIUM, TimeUnit.SECONDS);
}
/**
* 获取用户列表缓存
*/
public Object getUserListCache(String role, String keyword) {
String key = CacheConstant.USER_LIST_CACHE + role + ":" + keyword;
return redisUtil.get(key);
}
/**
* 缓存药品信息
*/
public void cacheMedicationInfo(Long medicationId, Object medicationInfo) {
String key = CacheConstant.MEDICATION_INFO_CACHE + medicationId;
redisUtil.set(key, medicationInfo, CacheConstant.CACHE_EXPIRE_MEDIUM, TimeUnit.SECONDS);
}
/**
* 获取药品信息缓存
*/
public Object getMedicationInfoCache(Long medicationId) {
String key = CacheConstant.MEDICATION_INFO_CACHE + medicationId;
return redisUtil.get(key);
}
/**
* 缓存健康数据统计
*/
public void cacheHealthDataStatistics(Long elderlyId, String dataType, Object statistics) {
String key = CacheConstant.HEALTH_DATA_STATISTICS_CACHE + elderlyId + ":" + dataType;
redisUtil.set(key, statistics, CacheConstant.STATISTICS_CACHE_EXPIRE, TimeUnit.SECONDS);
}
/**
* 获取健康数据统计缓存
*/
public Object getHealthDataStatisticsCache(Long elderlyId, String dataType) {
String key = CacheConstant.HEALTH_DATA_STATISTICS_CACHE + elderlyId + ":" + dataType;
return redisUtil.get(key);
}
/**
* 缓存JWT Token
*/
public void cacheJwtToken(String token, Object userInfo) {
String key = CacheConstant.JWT_TOKEN_CACHE_PREFIX + token;
redisUtil.set(key, userInfo, CacheConstant.JWT_TOKEN_EXPIRE, TimeUnit.SECONDS);
}
/**
* 获取JWT Token缓存
*/
public Object getJwtTokenCache(String token) {
String key = CacheConstant.JWT_TOKEN_CACHE_PREFIX + token;
return redisUtil.get(key);
}
/**
* 删除JWT Token缓存
*/
public boolean deleteJwtTokenCache(String token) {
String key = CacheConstant.JWT_TOKEN_CACHE_PREFIX + token;
return redisUtil.delete(key);
}
/**
* 清除用户相关所有缓存
*/
public void clearUserCache(Long userId) {
// 清除用户信息缓存
redisUtil.delete(CacheConstant.USER_INFO_CACHE + userId);
// 清除用户列表缓存
redisUtil.delete(CacheConstant.USER_LIST_CACHE + "*");
}
/**
* 清除药品相关所有缓存
*/
public void clearMedicationCache() {
redisUtil.delete(CacheConstant.MEDICATION_CACHE_PREFIX + "*");
}
/**
* 清除健康数据相关所有缓存
*/
public void clearHealthDataCache() {
redisUtil.delete(CacheConstant.HEALTH_DATA_CACHE_PREFIX + "*");
}
/**
* 清除所有缓存
*/
public void clearAllCache() {
redisUtil.delete("*");
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/CacheService.java | Java | unknown | 3,971 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.CommunityAnnouncement;
import java.util.List;
/**
* 社区公告服务接口
*/
public interface CommunityAnnouncementService extends IService<CommunityAnnouncement> {
// 获取最新的公告列表
List<CommunityAnnouncement> getLatestAnnouncements(Integer limit);
// 根据分类获取公告列表
List<CommunityAnnouncement> getAnnouncementsByCategory(String category, Integer limit);
// 增加公告阅读量
boolean increaseViewCount(Long announcementId);
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/CommunityAnnouncementService.java | Java | unknown | 629 |
package com.rahms.server.service;
import com.rahms.common.constant.AutoFillConstant;
import com.rahms.common.constant.CacheConstant;
import com.rahms.common.constant.JwtClaimsConstant;
import com.rahms.common.constant.MessageConstant;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
/**
* 常量服务类
* 提供所有常量类的统一访问接口
*/
@Service
public class ConstantService {
/**
* 获取所有消息常量
*/
public Map<String, String> getAllMessageConstants() {
Map<String, String> messages = new HashMap<>();
// 认证与登录相关
messages.put("PASSWORD_ERROR", MessageConstant.PASSWORD_ERROR);
messages.put("ACCOUNT_NOT_FOUND", MessageConstant.ACCOUNT_NOT_FOUND);
messages.put("ACCOUNT_DISABLE", MessageConstant.ACCOUNT_DISABLE);
messages.put("LOGIN_SUCCESS", MessageConstant.LOGIN_SUCCESS);
messages.put("LOGOUT_SUCCESS", MessageConstant.LOGOUT_SUCCESS);
messages.put("REGISTER_SUCCESS", MessageConstant.REGISTER_SUCCESS);
messages.put("UNAUTHORIZED_ACCESS", MessageConstant.UNAUTHORIZED_ACCESS);
messages.put("TOKEN_EXPIRED", MessageConstant.TOKEN_EXPIRED);
messages.put("INVALID_TOKEN", MessageConstant.INVALID_TOKEN);
// 用户管理相关
messages.put("USER_ADD_SUCCESS", MessageConstant.USER_ADD_SUCCESS);
messages.put("USER_UPDATE_SUCCESS", MessageConstant.USER_UPDATE_SUCCESS);
messages.put("USER_DELETE_SUCCESS", MessageConstant.USER_DELETE_SUCCESS);
messages.put("USER_NOT_EXIST", MessageConstant.USER_NOT_EXIST);
messages.put("USERNAME_EXISTS", MessageConstant.USERNAME_EXISTS);
messages.put("PHONE_EXISTS", MessageConstant.PHONE_EXISTS);
// 老人信息管理相关
messages.put("ELDERLY_ADD_SUCCESS", MessageConstant.ELDERLY_ADD_SUCCESS);
messages.put("ELDERLY_UPDATE_SUCCESS", MessageConstant.ELDERLY_UPDATE_SUCCESS);
messages.put("ELDERLY_DELETE_SUCCESS", MessageConstant.ELDERLY_DELETE_SUCCESS);
messages.put("ELDERLY_NOT_EXIST", MessageConstant.ELDERLY_NOT_EXIST);
messages.put("ELDERLY_NOT_BELONG", MessageConstant.ELDERLY_NOT_BELONG);
// 药品管理相关
messages.put("MEDICATION_ADD_SUCCESS", MessageConstant.MEDICATION_ADD_SUCCESS);
messages.put("MEDICATION_UPDATE_SUCCESS", MessageConstant.MEDICATION_UPDATE_SUCCESS);
messages.put("MEDICATION_DELETE_SUCCESS", MessageConstant.MEDICATION_DELETE_SUCCESS);
messages.put("MEDICATION_NOT_EXIST", MessageConstant.MEDICATION_NOT_EXIST);
messages.put("MEDICATION_NOT_BELONG", MessageConstant.MEDICATION_NOT_BELONG);
// 用药计划相关
messages.put("PLAN_ADD_SUCCESS", MessageConstant.PLAN_ADD_SUCCESS);
messages.put("PLAN_UPDATE_SUCCESS", MessageConstant.PLAN_UPDATE_SUCCESS);
messages.put("PLAN_DELETE_SUCCESS", MessageConstant.PLAN_DELETE_SUCCESS);
messages.put("PLAN_NOT_EXIST", MessageConstant.PLAN_NOT_EXIST);
messages.put("PLAN_ALREADY_STOPPED", MessageConstant.PLAN_ALREADY_STOPPED);
messages.put("PLAN_CONFIRM_SUCCESS", MessageConstant.PLAN_CONFIRM_SUCCESS);
// 健康数据相关
messages.put("HEALTH_DATA_ADD_SUCCESS", MessageConstant.HEALTH_DATA_ADD_SUCCESS);
messages.put("HEALTH_DATA_UPDATE_SUCCESS", MessageConstant.HEALTH_DATA_UPDATE_SUCCESS);
messages.put("HEALTH_DATA_DELETE_SUCCESS", MessageConstant.HEALTH_DATA_DELETE_SUCCESS);
messages.put("HEALTH_DATA_NOT_EXIST", MessageConstant.HEALTH_DATA_NOT_EXIST);
// 消息与公告相关
messages.put("NOTIFICATION_SEND_SUCCESS", MessageConstant.NOTIFICATION_SEND_SUCCESS);
messages.put("NOTIFICATION_READ_SUCCESS", MessageConstant.NOTIFICATION_READ_SUCCESS);
messages.put("NOTIFICATION_NOT_EXIST", MessageConstant.NOTIFICATION_NOT_EXIST);
messages.put("ANNOUNCEMENT_PUBLISH_SUCCESS", MessageConstant.ANNOUNCEMENT_PUBLISH_SUCCESS);
messages.put("ANNOUNCEMENT_UPDATE_SUCCESS", MessageConstant.ANNOUNCEMENT_UPDATE_SUCCESS);
messages.put("ANNOUNCEMENT_DELETE_SUCCESS", MessageConstant.ANNOUNCEMENT_DELETE_SUCCESS);
messages.put("ANNOUNCEMENT_NOT_EXIST", MessageConstant.ANNOUNCEMENT_NOT_EXIST);
// 文件操作相关
messages.put("FILE_UPLOAD_SUCCESS", MessageConstant.FILE_UPLOAD_SUCCESS);
messages.put("FILE_UPLOAD_FAILED", MessageConstant.FILE_UPLOAD_FAILED);
messages.put("FILE_DELETE_SUCCESS", MessageConstant.FILE_DELETE_SUCCESS);
messages.put("FILE_NOT_EXIST", MessageConstant.FILE_NOT_EXIST);
messages.put("FILE_FORMAT_ERROR", MessageConstant.FILE_FORMAT_ERROR);
messages.put("FILE_SIZE_EXCEED", MessageConstant.FILE_SIZE_EXCEED);
// 数据验证相关
messages.put("PARAM_IS_NULL", MessageConstant.PARAM_IS_NULL);
messages.put("PARAM_IS_INVALID", MessageConstant.PARAM_IS_INVALID);
messages.put("DATA_NOT_FOUND", MessageConstant.DATA_NOT_FOUND);
messages.put("DATA_ALREADY_EXISTS", MessageConstant.DATA_ALREADY_EXISTS);
// 操作结果相关
messages.put("OPERATION_SUCCESS", MessageConstant.OPERATION_SUCCESS);
messages.put("OPERATION_FAILED", MessageConstant.OPERATION_FAILED);
messages.put("SAVE_SUCCESS", MessageConstant.SAVE_SUCCESS);
messages.put("SAVE_FAILED", MessageConstant.SAVE_FAILED);
messages.put("DELETE_SUCCESS", MessageConstant.DELETE_SUCCESS);
messages.put("DELETE_FAILED", MessageConstant.DELETE_FAILED);
messages.put("UPDATE_SUCCESS", MessageConstant.UPDATE_SUCCESS);
messages.put("UPDATE_FAILED", MessageConstant.UPDATE_FAILED);
messages.put("QUERY_SUCCESS", MessageConstant.QUERY_SUCCESS);
messages.put("QUERY_FAILED", MessageConstant.QUERY_FAILED);
// 系统相关
messages.put("SYSTEM_ERROR", MessageConstant.SYSTEM_ERROR);
messages.put("NETWORK_ERROR", MessageConstant.NETWORK_ERROR);
messages.put("DATABASE_ERROR", MessageConstant.DATABASE_ERROR);
messages.put("SERVICE_UNAVAILABLE", MessageConstant.SERVICE_UNAVAILABLE);
messages.put("REQUEST_TIMEOUT", MessageConstant.REQUEST_TIMEOUT);
// 权限相关
messages.put("PERMISSION_DENIED", MessageConstant.PERMISSION_DENIED);
messages.put("ROLE_NOT_EXIST", MessageConstant.ROLE_NOT_EXIST);
messages.put("NEED_ADMIN_ROLE", MessageConstant.NEED_ADMIN_ROLE);
messages.put("NEED_FAMILY_ROLE", MessageConstant.NEED_FAMILY_ROLE);
// 导出相关
messages.put("EXPORT_SUCCESS", MessageConstant.EXPORT_SUCCESS);
messages.put("EXPORT_FAILED", MessageConstant.EXPORT_FAILED);
// 提醒相关
messages.put("REMINDER_SENT", MessageConstant.REMINDER_SENT);
messages.put("REMINDER_MISSED", MessageConstant.REMINDER_MISSED);
messages.put("REMINDER_CONFIRMED", MessageConstant.REMINDER_CONFIRMED);
return messages;
}
/**
* 获取所有缓存常量
*/
public Map<String, Object> getAllCacheConstants() {
Map<String, Object> cacheConstants = new HashMap<>();
// 缓存前缀
cacheConstants.put("USER_CACHE_PREFIX", CacheConstant.USER_CACHE_PREFIX);
cacheConstants.put("USER_INFO_CACHE", CacheConstant.USER_INFO_CACHE);
cacheConstants.put("USER_LIST_CACHE", CacheConstant.USER_LIST_CACHE);
cacheConstants.put("ELDERLY_CACHE_PREFIX", CacheConstant.ELDERLY_CACHE_PREFIX);
cacheConstants.put("ELDERLY_INFO_CACHE", CacheConstant.ELDERLY_INFO_CACHE);
cacheConstants.put("ELDERLY_LIST_CACHE", CacheConstant.ELDERLY_LIST_CACHE);
cacheConstants.put("MEDICATION_CACHE_PREFIX", CacheConstant.MEDICATION_CACHE_PREFIX);
cacheConstants.put("MEDICATION_INFO_CACHE", CacheConstant.MEDICATION_INFO_CACHE);
cacheConstants.put("MEDICATION_LIST_CACHE", CacheConstant.MEDICATION_LIST_CACHE);
cacheConstants.put("DRUG_PLAN_CACHE_PREFIX", CacheConstant.DRUG_PLAN_CACHE_PREFIX);
cacheConstants.put("DRUG_PLAN_INFO_CACHE", CacheConstant.DRUG_PLAN_INFO_CACHE);
cacheConstants.put("DRUG_PLAN_LIST_CACHE", CacheConstant.DRUG_PLAN_LIST_CACHE);
cacheConstants.put("DRUG_PLAN_ACTIVE_CACHE", CacheConstant.DRUG_PLAN_ACTIVE_CACHE);
cacheConstants.put("HEALTH_DATA_CACHE_PREFIX", CacheConstant.HEALTH_DATA_CACHE_PREFIX);
cacheConstants.put("HEALTH_DATA_LIST_CACHE", CacheConstant.HEALTH_DATA_LIST_CACHE);
cacheConstants.put("HEALTH_DATA_STATISTICS_CACHE", CacheConstant.HEALTH_DATA_STATISTICS_CACHE);
cacheConstants.put("NOTIFICATION_CACHE_PREFIX", CacheConstant.NOTIFICATION_CACHE_PREFIX);
cacheConstants.put("NOTIFICATION_LIST_CACHE", CacheConstant.NOTIFICATION_LIST_CACHE);
cacheConstants.put("NOTIFICATION_UNREAD_COUNT_CACHE", CacheConstant.NOTIFICATION_UNREAD_COUNT_CACHE);
cacheConstants.put("SYSTEM_MESSAGE_CACHE_PREFIX", CacheConstant.SYSTEM_MESSAGE_CACHE_PREFIX);
cacheConstants.put("SYSTEM_MESSAGE_LIST_CACHE", CacheConstant.SYSTEM_MESSAGE_LIST_CACHE);
cacheConstants.put("ANNOUNCEMENT_CACHE_PREFIX", CacheConstant.ANNOUNCEMENT_CACHE_PREFIX);
cacheConstants.put("ANNOUNCEMENT_INFO_CACHE", CacheConstant.ANNOUNCEMENT_INFO_CACHE);
cacheConstants.put("ANNOUNCEMENT_LIST_CACHE", CacheConstant.ANNOUNCEMENT_LIST_CACHE);
cacheConstants.put("ANNOUNCEMENT_LATEST_CACHE", CacheConstant.ANNOUNCEMENT_LATEST_CACHE);
cacheConstants.put("JWT_TOKEN_CACHE_PREFIX", CacheConstant.JWT_TOKEN_CACHE_PREFIX);
cacheConstants.put("JWT_USER_CACHE_PREFIX", CacheConstant.JWT_USER_CACHE_PREFIX);
// 缓存过期时间
cacheConstants.put("CACHE_EXPIRE_SHORT", CacheConstant.CACHE_EXPIRE_SHORT);
cacheConstants.put("CACHE_EXPIRE_MEDIUM", CacheConstant.CACHE_EXPIRE_MEDIUM);
cacheConstants.put("CACHE_EXPIRE_LONG", CacheConstant.CACHE_EXPIRE_LONG);
cacheConstants.put("CACHE_EXPIRE_VERY_LONG", CacheConstant.CACHE_EXPIRE_VERY_LONG);
cacheConstants.put("JWT_TOKEN_EXPIRE", CacheConstant.JWT_TOKEN_EXPIRE);
cacheConstants.put("USER_SESSION_EXPIRE", CacheConstant.USER_SESSION_EXPIRE);
cacheConstants.put("STATISTICS_CACHE_EXPIRE", CacheConstant.STATISTICS_CACHE_EXPIRE);
return cacheConstants;
}
/**
* 获取所有JWT声明常量
*/
public Map<String, String> getAllJwtClaimsConstants() {
Map<String, String> jwtClaims = new HashMap<>();
jwtClaims.put("EMP_ID", JwtClaimsConstant.EMP_ID);
jwtClaims.put("USER_ID", JwtClaimsConstant.USER_ID);
jwtClaims.put("PHONE", JwtClaimsConstant.PHONE);
jwtClaims.put("USERNAME", JwtClaimsConstant.USERNAME);
jwtClaims.put("NAME", JwtClaimsConstant.NAME);
return jwtClaims;
}
/**
* 获取所有自动填充常量
*/
public Map<String, String> getAllAutoFillConstants() {
Map<String, String> autoFill = new HashMap<>();
autoFill.put("SET_CREATE_TIME", AutoFillConstant.SET_CREATE_TIME);
autoFill.put("SET_UPDATE_TIME", AutoFillConstant.SET_UPDATE_TIME);
autoFill.put("SET_CREATE_USER", AutoFillConstant.SET_CREATE_USER);
autoFill.put("SET_UPDATE_USER", AutoFillConstant.SET_UPDATE_USER);
return autoFill;
}
/**
* 获取所有常量
*/
public Map<String, Object> getAllConstants() {
Map<String, Object> allConstants = new HashMap<>();
allConstants.put("messages", getAllMessageConstants());
allConstants.put("cache", getAllCacheConstants());
allConstants.put("jwtClaims", getAllJwtClaimsConstants());
allConstants.put("autoFill", getAllAutoFillConstants());
return allConstants;
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/ConstantService.java | Java | unknown | 12,003 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.DrugPlan;
import java.util.List;
/**
* 用药计划服务接口
*/
public interface DrugPlanService extends IService<DrugPlan> {
// 根据老人ID获取用药计划列表
List<DrugPlan> getDrugPlansByElderlyId(Long elderlyId);
// 获取生效中的用药计划
List<DrugPlan> getActiveDrugPlans();
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/DrugPlanService.java | Java | unknown | 453 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.ElderlyInfo;
import java.util.List;
/**
* 老人信息服务接口
*/
public interface ElderlyInfoService extends IService<ElderlyInfo> {
// 根据家属用户ID获取老人列表
List<ElderlyInfo> getElderlyListByUserId(Long userId);
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/ElderlyInfoService.java | Java | unknown | 377 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.HealthData;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
/**
* 健康数据服务接口
*/
public interface HealthDataService extends IService<HealthData> {
// 根据老人ID和数据类型获取健康数据
List<HealthData> getHealthDataByElderlyIdAndType(Long elderlyId, String dataType);
// 获取指定日期范围内的健康数据
List<HealthData> getHealthDataByDateRange(Long elderlyId, String dataType, LocalDateTime startDate, LocalDateTime endDate);
// 获取健康数据统计信息
Map<String, Object> getHealthDataStatistics(Long elderlyId, String dataType, LocalDateTime startDate, LocalDateTime endDate);
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/HealthDataService.java | Java | unknown | 821 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.MedicationReminderLog;
import java.time.LocalDateTime;
import java.util.List;
/**
* 用药提醒记录服务接口
*/
public interface MedicationReminderLogService extends IService<MedicationReminderLog> {
// 根据计划ID获取提醒记录
List<MedicationReminderLog> getLogsByPlanId(Long planId);
// 根据老人ID获取提醒记录
List<MedicationReminderLog> getLogsByElderlyId(Long elderlyId);
// 获取指定日期范围内的提醒记录
List<MedicationReminderLog> getLogsByDateRange(Long elderlyId, LocalDateTime startDate, LocalDateTime endDate);
// 确认用药
boolean confirmMedication(Long logId, Long userId);
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/MedicationReminderLogService.java | Java | unknown | 807 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.Medication;
import java.util.List;
/**
* 药品服务接口
*/
public interface MedicationService extends IService<Medication> {
// 根据用户ID获取药品列表
List<Medication> getMedicationListByUserId(Long userId);
// 根据关键词搜索药品
List<Medication> searchMedications(Long userId, String keyword);
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/MedicationService.java | Java | unknown | 473 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.Notification;
import java.util.List;
/**
* 消息通知服务接口
*/
public interface NotificationService extends IService<Notification> {
// 根据用户ID获取消息列表
List<Notification> getNotificationsByUserId(Long userId, String type, Integer isRead);
// 获取未读消息数量
int getUnreadCountByUserId(Long userId);
// 标记消息为已读
boolean markAsRead(Long notiId);
// 批量标记消息为已读
boolean batchMarkAsRead(List<Long> notiIds);
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/NotificationService.java | Java | unknown | 648 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.SystemMessage;
import java.util.List;
/**
* 系统消息服务接口
*/
public interface SystemMessageService extends IService<SystemMessage> {
// 根据接收者ID获取消息列表
List<SystemMessage> getMessagesByRecipientId(Long recipientId, String msgType, Integer isRead);
// 发送系统消息
boolean sendSystemMessage(SystemMessage message);
// 标记消息为已读
boolean markMessageAsRead(Long messageId);
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/SystemMessageService.java | Java | unknown | 587 |
package com.rahms.server.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rahms.pojo.entity.User;
import java.util.List;
/**
* 用户服务接口
*/
public interface UserService extends IService<User> {
/**
* 根据用户名获取用户信息（带缓存）
*/
User getUserByUsername(String username);
/**
* 根据用户ID获取用户信息（带缓存）
*/
User getUserById(Long userId);
/**
* 获取用户列表（带缓存）
*/
List<User> getUserList(String role, String keyword);
/**
* 清除用户相关缓存
*/
void clearUserCache(Long userId);
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/UserService.java | Java | unknown | 683 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rahms.pojo.entity.CommunityAnnouncement;
import com.rahms.server.mapper.CommunityAnnouncementMapper;
import com.rahms.server.service.CommunityAnnouncementService;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 社区公告服务实现类
*/
@Service
public class CommunityAnnouncementServiceImpl extends ServiceImpl<CommunityAnnouncementMapper, CommunityAnnouncement> implements CommunityAnnouncementService {
@Override
public List<CommunityAnnouncement> getLatestAnnouncements(Integer limit) {
LambdaQueryWrapper<CommunityAnnouncement> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CommunityAnnouncement::getStatus, 1) // 只查询已发布的公告
.orderByDesc(CommunityAnnouncement::getPublishTime)
.last(limit != null && limit > 0, "LIMIT " + limit);
return this.list(queryWrapper);
}
@Override
public List<CommunityAnnouncement> getAnnouncementsByCategory(String category, Integer limit) {
LambdaQueryWrapper<CommunityAnnouncement> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CommunityAnnouncement::getStatus, 1) // 只查询已发布的公告
.eq(category != null && !category.isEmpty(), CommunityAnnouncement::getCategory, category)
.orderByDesc(CommunityAnnouncement::getPublishTime)
.last(limit != null && limit > 0, "LIMIT " + limit);
return this.list(queryWrapper);
}
@Override
public boolean increaseViewCount(Long announcementId) {
CommunityAnnouncement announcement = this.getById(announcementId);
if (announcement != null) {
announcement.setViewCount(announcement.getViewCount() + 1);
return this.updateById(announcement);
}
return false;
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/CommunityAnnouncementServiceImpl.java | Java | unknown | 2,064 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rahms.pojo.entity.DrugPlan;
import com.rahms.server.mapper.DrugPlanMapper;
import com.rahms.server.service.DrugPlanService;
import org.springframework.stereotype.Service;
import java.time.LocalDate;
import java.util.List;
/**
* 用药计划服务实现类
*/
@Service
public class DrugPlanServiceImpl extends ServiceImpl<DrugPlanMapper, DrugPlan> implements DrugPlanService {
@Override
public List<DrugPlan> getDrugPlansByElderlyId(Long elderlyId) {
LambdaQueryWrapper<DrugPlan> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DrugPlan::getElderlyId, elderlyId);
return this.list(queryWrapper);
}
@Override
public List<DrugPlan> getActiveDrugPlans() {
LocalDate now = LocalDate.now();
LambdaQueryWrapper<DrugPlan> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DrugPlan::getStatus, 1) // 状态为生效中
.le(DrugPlan::getStartDate, now) // 开始日期小于等于今天
.and(wrapper -> wrapper.isNull(DrugPlan::getEndDate).or().ge(DrugPlan::getEndDate, now)); // 结束日期为空或大于等于今天
return this.list(queryWrapper);
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/DrugPlanServiceImpl.java | Java | unknown | 1,393 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rahms.pojo.entity.ElderlyInfo;
import com.rahms.server.mapper.ElderlyInfoMapper;
import com.rahms.server.service.ElderlyInfoService;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 老人信息服务实现类
*/
@Service
public class ElderlyInfoServiceImpl extends ServiceImpl<ElderlyInfoMapper, ElderlyInfo> implements ElderlyInfoService {
@Override
public List<ElderlyInfo> getElderlyListByUserId(Long userId) {
LambdaQueryWrapper<ElderlyInfo> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ElderlyInfo::getUserId, userId);
return this.list(queryWrapper);
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/ElderlyInfoServiceImpl.java | Java | unknown | 839 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rahms.pojo.entity.HealthData;
import com.rahms.server.mapper.HealthDataMapper;
import com.rahms.server.service.HealthDataService;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.*;
/**
* 健康数据服务实现类
*/
@Service
public class HealthDataServiceImpl extends ServiceImpl<HealthDataMapper, HealthData> implements HealthDataService {
@Override
public List<HealthData> getHealthDataByElderlyIdAndType(Long elderlyId, String dataType) {
LambdaQueryWrapper<HealthData> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(HealthData::getElderlyId, elderlyId)
.eq(HealthData::getDataType, dataType)
.orderByDesc(HealthData::getRecordTime);
return this.list(queryWrapper);
}
@Override
public List<HealthData> getHealthDataByDateRange(Long elderlyId, String dataType, LocalDateTime startDate, LocalDateTime endDate) {
LambdaQueryWrapper<HealthData> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(HealthData::getElderlyId, elderlyId)
.eq(dataType != null && !dataType.isEmpty(), HealthData::getDataType, dataType)
.between(HealthData::getRecordTime, startDate, endDate)
.orderByDesc(HealthData::getRecordTime);
return this.list(queryWrapper);
}
@Override
public Map<String, Object> getHealthDataStatistics(Long elderlyId, String dataType, LocalDateTime startDate, LocalDateTime endDate) {
List<HealthData> dataList = getHealthDataByDateRange(elderlyId, dataType, startDate, endDate);
Map<String, Object> statistics = new HashMap<>();
if (dataList.isEmpty()) {
statistics.put("count", 0);
statistics.put("average", null);
statistics.put("max", null);
statistics.put("min", null);
return statistics;
}
statistics.put("count", dataList.size());
// 根据数据类型计算统计值
if ("blood_pressure".equals(dataType)) {
// 处理血压数据 "120/80"
double sumSystolic = 0, sumDiastolic = 0;
double maxSystolic = Double.MIN_VALUE, maxDiastolic = Double.MIN_VALUE;
double minSystolic = Double.MAX_VALUE, minDiastolic = Double.MAX_VALUE;
for (HealthData data : dataList) {
try {
String[] values = data.getDataValue().split("/");
double systolic = Double.parseDouble(values[0]);
double diastolic = Double.parseDouble(values[1]);
sumSystolic += systolic;
sumDiastolic += diastolic;
maxSystolic = Math.max(maxSystolic, systolic);
maxDiastolic = Math.max(maxDiastolic, diastolic);
minSystolic = Math.min(minSystolic, systolic);
minDiastolic = Math.min(minDiastolic, diastolic);
} catch (Exception e) {
// 忽略格式错误的数据
}
}
statistics.put("averageSystolic", sumSystolic / dataList.size());
statistics.put("averageDiastolic", sumDiastolic / dataList.size());
statistics.put("maxSystolic", maxSystolic);
statistics.put("maxDiastolic", maxDiastolic);
statistics.put("minSystolic", minSystolic);
statistics.put("minDiastolic", minDiastolic);
} else {
// 处理其他类型的数值数据
double sum = 0;
double max = Double.MIN_VALUE;
double min = Double.MAX_VALUE;
for (HealthData data : dataList) {
try {
double value = Double.parseDouble(data.getDataValue());
sum += value;
max = Math.max(max, value);
min = Math.min(min, value);
} catch (Exception e) {
// 忽略格式错误的数据
}
}
statistics.put("average", sum / dataList.size());
statistics.put("max", max);
statistics.put("min", min);
}
return statistics;
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/HealthDataServiceImpl.java | Java | unknown | 4,624 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rahms.pojo.entity.MedicationReminderLog;
import com.rahms.server.mapper.MedicationReminderLogMapper;
import com.rahms.server.service.MedicationReminderLogService;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
/**
* 用药提醒记录服务实现类
*/
@Service
public class MedicationReminderLogServiceImpl extends ServiceImpl<MedicationReminderLogMapper, MedicationReminderLog> implements MedicationReminderLogService {
@Override
public List<MedicationReminderLog> getLogsByPlanId(Long planId) {
LambdaQueryWrapper<MedicationReminderLog> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(MedicationReminderLog::getPlanId, planId);
return this.list(queryWrapper);
}
@Override
public List<MedicationReminderLog> getLogsByElderlyId(Long elderlyId) {
LambdaQueryWrapper<MedicationReminderLog> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(MedicationReminderLog::getElderlyId, elderlyId);
return this.list(queryWrapper);
}
@Override
public List<MedicationReminderLog> getLogsByDateRange(Long elderlyId, LocalDateTime startDate, LocalDateTime endDate) {
LambdaQueryWrapper<MedicationReminderLog> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(MedicationReminderLog::getElderlyId, elderlyId)
.between(MedicationReminderLog::getScheduledTime, startDate, endDate);
return this.list(queryWrapper);
}
@Override
public boolean confirmMedication(Long logId, Long userId) {
MedicationReminderLog log = this.getById(logId);
if (log != null && log.getStatus() != 2) { // 不是已确认状态
log.setStatus(2); // 设置为已确认
log.setConfirmTime(LocalDateTime.now());
log.setConfirmedBy(userId);
return this.updateById(log);
}
return false;
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/MedicationReminderLogServiceImpl.java | Java | unknown | 2,163 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rahms.pojo.entity.Medication;
import com.rahms.server.mapper.MedicationMapper;
import com.rahms.server.service.MedicationService;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 药品服务实现类
*/
@Service
public class MedicationServiceImpl extends ServiceImpl<MedicationMapper, Medication> implements MedicationService {
@Override
public List<Medication> getMedicationListByUserId(Long userId) {
LambdaQueryWrapper<Medication> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Medication::getUserId, userId);
return this.list(queryWrapper);
}
@Override
public List<Medication> searchMedications(Long userId, String keyword) {
LambdaQueryWrapper<Medication> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Medication::getUserId, userId)
.like(keyword != null && !keyword.isEmpty(), Medication::getMedName, keyword);
return this.list(queryWrapper);
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/MedicationServiceImpl.java | Java | unknown | 1,203 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rahms.pojo.entity.Notification;
import com.rahms.server.mapper.NotificationMapper;
import com.rahms.server.service.NotificationService;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 消息通知服务实现类
*/
@Service
public class NotificationServiceImpl extends ServiceImpl<NotificationMapper, Notification> implements NotificationService {
@Override
public List<Notification> getNotificationsByUserId(Long userId, String type, Integer isRead) {
LambdaQueryWrapper<Notification> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Notification::getUserId, userId)
.eq(type != null && !type.isEmpty(), Notification::getNotiType, type)
.eq(isRead != null, Notification::getIsRead, isRead)
.orderByDesc(Notification::getCreateTime);
return this.list(queryWrapper);
}
@Override
public int getUnreadCountByUserId(Long userId) {
LambdaQueryWrapper<Notification> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Notification::getUserId, userId)
.eq(Notification::getIsRead, 0);
return (int) this.count(queryWrapper);
}
@Override
public boolean markAsRead(Long notiId) {
Notification notification = this.getById(notiId);
if (notification != null) {
notification.setIsRead(1);
return this.updateById(notification);
}
return false;
}
@Override
public boolean batchMarkAsRead(List<Long> notiIds) {
if (notiIds == null || notiIds.isEmpty()) {
return true;
}
LambdaQueryWrapper<Notification> updateWrapper = new LambdaQueryWrapper<>();
updateWrapper.in(Notification::getNotiId, notiIds);
Notification notification = new Notification();
notification.setIsRead(1);
return this.update(notification, updateWrapper);
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/NotificationServiceImpl.java | Java | unknown | 2,167 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rahms.pojo.entity.SystemMessage;
import com.rahms.server.mapper.SystemMessageMapper;
import com.rahms.server.service.SystemMessageService;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
/**
* 系统消息服务实现类
*/
@Service
public class SystemMessageServiceImpl extends ServiceImpl<SystemMessageMapper, SystemMessage> implements SystemMessageService {
@Override
public List<SystemMessage> getMessagesByRecipientId(Long recipientId, String msgType, Integer isRead) {
LambdaQueryWrapper<SystemMessage> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SystemMessage::getRecipientId, recipientId)
.eq(msgType != null && !msgType.isEmpty(), SystemMessage::getMsgType, msgType)
.eq(isRead != null, SystemMessage::getIsRead, isRead)
.orderByDesc(SystemMessage::getSendTime);
return this.list(queryWrapper);
}
@Override
public boolean sendSystemMessage(SystemMessage message) {
if (message == null) {
return false;
}
message.setIsRead(0); // 默认未读
message.setSendTime(LocalDateTime.now());
// 如果没有设置过期时间，默认设置为7天后
if (message.getExpireTime() == null) {
message.setExpireTime(LocalDateTime.now().plusDays(7));
}
return this.save(message);
}
@Override
public boolean markMessageAsRead(Long messageId) {
SystemMessage message = this.getById(messageId);
if (message != null) {
message.setIsRead(1);
return this.updateById(message);
}
return false;
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/SystemMessageServiceImpl.java | Java | unknown | 1,955 |
package com.rahms.server.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.rahms.common.constant.CacheConstant;
import com.rahms.pojo.entity.User;
import com.rahms.server.mapper.UserMapper;
import com.rahms.server.service.UserService;
import com.rahms.server.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* 用户服务实现类
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Autowired
private RedisUtil redisUtil;
@Override
@Cacheable(value = "user", key = "#username", unless = "#result == null")
public User getUserByUsername(String username) {
// 先尝试从缓存获取
String cacheKey = CacheConstant.USER_INFO_CACHE + username;
User cachedUser = redisUtil.get(cacheKey, User.class);
if (cachedUser != null) {
return cachedUser;
}
// 缓存未命中，从数据库查询
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getUsername, username);
User user = this.getOne(queryWrapper);
// 将结果缓存
if (user != null) {
redisUtil.set(cacheKey, user, CacheConstant.CACHE_EXPIRE_MEDIUM, TimeUnit.SECONDS);
}
return user;
}
@Override
@Cacheable(value = "user", key = "#userId", unless = "#result == null")
public User getUserById(Long userId) {
// 先尝试从缓存获取
String cacheKey = CacheConstant.USER_INFO_CACHE + userId;
User cachedUser = redisUtil.get(cacheKey, User.class);
if (cachedUser != null) {
return cachedUser;
}
// 缓存未命中，从数据库查询
User user = this.getById(userId);
// 将结果缓存
if (user != null) {
redisUtil.set(cacheKey, user, CacheConstant.CACHE_EXPIRE_MEDIUM, TimeUnit.SECONDS);
}
return user;
}
@Override
@Cacheable(value = "userList", key = "#role + ':' + #keyword", unless = "#result == null || #result.isEmpty()")
public List<User> getUserList(String role, String keyword) {
// 先尝试从缓存获取
String cacheKey = CacheConstant.USER_LIST_CACHE + role + ":" + keyword;
List<User> cachedList = redisUtil.get(cacheKey, List.class);
if (cachedList != null) {
return cachedList;
}
// 缓存未命中，从数据库查询
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
if (role != null && !role.isEmpty()) {
queryWrapper.eq(User::getRole, role);
}
if (keyword != null && !keyword.isEmpty()) {
queryWrapper.like(User::getUsername, keyword);
}
List<User> userList = this.list(queryWrapper);
// 将结果缓存
if (userList != null && !userList.isEmpty()) {
redisUtil.set(cacheKey, userList, CacheConstant.CACHE_EXPIRE_MEDIUM, TimeUnit.SECONDS);
}
return userList;
}
@Override
@CacheEvict(value = {"user", "userList"}, allEntries = true)
public void clearUserCache(Long userId) {
// 清除特定用户的缓存
redisUtil.delete(CacheConstant.USER_INFO_CACHE + userId);
redisUtil.delete(CacheConstant.USER_LIST_CACHE + "*");
}
@Override
public boolean save(User user) {
boolean result = super.save(user);
if (result) {
// 保存成功后清除相关缓存
clearUserCache(user.getUserId());
}
return result;
}
@Override
public boolean updateById(User user) {
boolean result = super.updateById(user);
if (result) {
// 更新成功后清除相关缓存
clearUserCache(user.getUserId());
}
return result;
}
@Override
public boolean removeById(Long userId) {
boolean result = super.removeById(userId);
if (result) {
// 删除成功后清除相关缓存
clearUserCache(userId);
}
return result;
}
} | 2401_83195498/community_elder | server/src/main/java/com/rahms/server/service/impl/UserServiceImpl.java | Java | unknown | 4,518 |
package com.rahms.server.utils;
import com.rahms.common.constant.AutoFillConstant;
import com.rahms.common.constant.CacheConstant;
import com.rahms.common.constant.JwtClaimsConstant;
import com.rahms.common.constant.MessageConstant;
import org.springframework.stereotype.Component;
/**
* 常量工具类
* 提供常量相关的工具方法
*/
@Component
public class ConstantUtil {
/**
* 构建用户信息缓存键
*/
public static String buildUserInfoCacheKey(Long userId) {
return CacheConstant.USER_INFO_CACHE + userId;
}
/**
* 构建用户信息缓存键（按用户名）
*/
public static String buildUserInfoCacheKey(String username) {
return CacheConstant.USER_INFO_CACHE + username;
}
/**
* 构建用户列表缓存键
*/
public static String buildUserListCacheKey(String role, String keyword) {
return CacheConstant.USER_LIST_CACHE + role + ":" + keyword;
}
/**
* 构建老人信息缓存键
*/
public static String buildElderlyInfoCacheKey(Long elderlyId) {
return CacheConstant.ELDERLY_INFO_CACHE + elderlyId;
}
/**
* 构建老人列表缓存键
*/
public static String buildElderlyListCacheKey(Long userId) {
return CacheConstant.ELDERLY_LIST_CACHE + userId;
}
/**
* 构建药品信息缓存键
*/
public static String buildMedicationInfoCacheKey(Long medicationId) {
return CacheConstant.MEDICATION_INFO_CACHE + medicationId;
}
/**
* 构建药品列表缓存键
*/
public static String buildMedicationListCacheKey(Long userId, String keyword) {
return CacheConstant.MEDICATION_LIST_CACHE + userId + ":" + keyword;
}
/**
* 构建用药计划信息缓存键
*/
public static String buildDrugPlanInfoCacheKey(Long planId) {
return CacheConstant.DRUG_PLAN_INFO_CACHE + planId;
}
/**
* 构建用药计划列表缓存键
*/
public static String buildDrugPlanListCacheKey(Long elderlyId) {
return CacheConstant.DRUG_PLAN_LIST_CACHE + elderlyId;
}
/**
* 构建活跃用药计划缓存键
*/
public static String buildActiveDrugPlanCacheKey(Long elderlyId) {
return CacheConstant.DRUG_PLAN_ACTIVE_CACHE + elderlyId;
}
/**
* 构建健康数据列表缓存键
*/
public static String buildHealthDataListCacheKey(Long elderlyId, String dataType) {
return CacheConstant.HEALTH_DATA_LIST_CACHE + elderlyId + ":" + dataType;
}
/**
* 构建健康数据统计缓存键
*/
public static String buildHealthDataStatisticsCacheKey(Long elderlyId, String dataType) {
return CacheConstant.HEALTH_DATA_STATISTICS_CACHE + elderlyId + ":" + dataType;
}
/**
* 构建消息列表缓存键
*/
public static String buildNotificationListCacheKey(Long userId, String type) {
return CacheConstant.NOTIFICATION_LIST_CACHE + userId + ":" + type;
}
/**
* 构建未读消息数量缓存键
*/
public static String buildUnreadCountCacheKey(Long userId) {
return CacheConstant.NOTIFICATION_UNREAD_COUNT_CACHE + userId;
}
/**
* 构建系统消息列表缓存键
*/
public static String buildSystemMessageListCacheKey(Long userId) {
return CacheConstant.SYSTEM_MESSAGE_LIST_CACHE + userId;
}
/**
* 构建公告信息缓存键
*/
public static String buildAnnouncementInfoCacheKey(Long announceId) {
return CacheConstant.ANNOUNCEMENT_INFO_CACHE + announceId;
}
/**
* 构建公告列表缓存键
*/
public static String buildAnnouncementListCacheKey(String status) {
return CacheConstant.ANNOUNCEMENT_LIST_CACHE + status;
}
/**
* 构建最新公告缓存键
*/
public static String buildLatestAnnouncementCacheKey() {
return CacheConstant.ANNOUNCEMENT_LATEST_CACHE + "latest";
}
/**
* 构建JWT Token缓存键
*/
public static String buildJwtTokenCacheKey(String token) {
return CacheConstant.JWT_TOKEN_CACHE_PREFIX + token;
}
/**
* 构建JWT用户缓存键
*/
public static String buildJwtUserCacheKey(Long userId) {
return CacheConstant.JWT_USER_CACHE_PREFIX + userId;
}
/**
* 获取缓存过期时间
*/
public static long getCacheExpireTime(String type) {
switch (type.toLowerCase()) {
case "short":
return CacheConstant.CACHE_EXPIRE_SHORT;
case "medium":
return CacheConstant.CACHE_EXPIRE_MEDIUM;
case "long":
return CacheConstant.CACHE_EXPIRE_LONG;
case "very_long":
return CacheConstant.CACHE_EXPIRE_VERY_LONG;
case "jwt_token":
return CacheConstant.JWT_TOKEN_EXPIRE;
case "user_session":
return CacheConstant.USER_SESSION_EXPIRE;
case "statistics":
return CacheConstant.STATISTICS_CACHE_EXPIRE;
default:
return CacheConstant.CACHE_EXPIRE_MEDIUM;
}
}
/**
* 获取JWT声明字段名
*/
public static String getJwtClaimField(String field) {
switch (field.toLowerCase()) {
case "emp_id":
return JwtClaimsConstant.EMP_ID;
case "user_id":
return JwtClaimsConstant.USER_ID;
case "phone":
return JwtClaimsConstant.PHONE;
case "username":
return JwtClaimsConstant.USERNAME;
case "name":
return JwtClaimsConstant.NAME;
default:
return field;
}
}
/**
* 获取自动填充方法名
*/
public static String getAutoFillMethod(String method) {
switch (method.toLowerCase()) {
case "create_time":
return AutoFillConstant.SET_CREATE_TIME;
case "update_time":
return AutoFillConstant.SET_UPDATE_TIME;
case "create_user":
return AutoFillConstant.SET_CREATE_USER;
case "update_user":
return AutoFillConstant.SET_UPDATE_USER;
default:
return method;
}
}
/**
* 获取消息常量
*/
public static String getMessage(String key) {
switch (key.toLowerCase()) {
case "password_error":
return MessageConstant.PASSWORD_ERROR;
case "account_not_found":
return MessageConstant.ACCOUNT_NOT_FOUND;
case "login_success":
return MessageConstant.LOGIN_SUCCESS;
case "register_success":
return MessageConstant.REGISTER_SUCCESS;
case "user_not_exist":
return MessageConstant.USER_NOT_EXIST;
case "username_exists":
return MessageConstant.USERNAME_EXISTS;
case "operation_success":
return MessageConstant.OPERATION_SUCCESS;
case "operation_failed":
return MessageConstant.OPERATION_FAILED;
case "save_success":
return MessageConstant.SAVE_SUCCESS;
case "save_failed":
return MessageConstant.SAVE_FAILED;
case "update_success":
return MessageConstant.UPDATE_SUCCESS;
case "update_failed":
return MessageConstant.UPDATE_FAILED;
case "delete_success":
return MessageConstant.DELETE_SUCCESS;
case "delete_failed":
return MessageConstant.DELETE_FAILED;
case "query_success":
return MessageConstant.QUERY_SUCCESS;
case "query_failed":
return MessageConstant.QUERY_FAILED;
case "system_error":
return MessageConstant.SYSTEM_ERROR;
case "permission_denied":
return MessageConstant.PERMISSION_DENIED;
default:
return key;
}
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/utils/ConstantUtil.java | Java | unknown | 8,205 |
package com.rahms.server.utils;
import com.rahms.common.constant.CacheConstant;
import com.rahms.common.constant.JwtClaimsConstant;
import com.rahms.common.properties.JwtProperties;
import com.rahms.common.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* JWT Token 工具类
*/
@Component
public class JwtTokenUtil {
@Autowired
private JwtProperties jwtProperties;
@Autowired
private RedisUtil redisUtil;
/**
* 生成JWT令牌
*/
public String generateToken(Long userId, String username, String phone, String realName) {
String token = JwtUtil.generateToken(
userId.toString(),
jwtProperties.getIssuer(),
jwtProperties.getSecret(),
jwtProperties.getTtlSeconds()
);
// 将token和用户信息缓存到Redis
String cacheKey = CacheConstant.JWT_TOKEN_CACHE_PREFIX + token;
redisUtil.set(cacheKey, userId, CacheConstant.JWT_TOKEN_EXPIRE, TimeUnit.SECONDS);
return token;
}
/**
* 解析JWT令牌
*/
public Claims parseToken(String token) {
return JwtUtil.parseToken(token, jwtProperties.getSecret());
}
/**
* 从令牌中获取用户ID
*/
public Long getUserIdFromToken(String token) {
Claims claims = parseToken(token);
return Long.valueOf(claims.getSubject());
}
/**
* 从令牌中获取用户名
*/
public String getUsernameFromToken(String token) {
Claims claims = parseToken(token);
return claims.get(JwtClaimsConstant.USERNAME, String.class);
}
/**
* 从令牌中获取手机号
*/
public String getPhoneFromToken(String token) {
Claims claims = parseToken(token);
return claims.get(JwtClaimsConstant.PHONE, String.class);
}
/**
* 从令牌中获取真实姓名
*/
public String getNameFromToken(String token) {
Claims claims = parseToken(token);
return claims.get(JwtClaimsConstant.NAME, String.class);
}
/**
* 验证令牌是否有效
*/
public boolean validateToken(String token) {
try {
// 先检查Redis缓存
String cacheKey = CacheConstant.JWT_TOKEN_CACHE_PREFIX + token;
if (!redisUtil.hasKey(cacheKey)) {
return false;
}
// 再验证JWT本身
parseToken(token);
return true;
} catch (Exception e) {
return false;
}
}
/**
* 使令牌失效
*/
public boolean invalidateToken(String token) {
try {
String cacheKey = CacheConstant.JWT_TOKEN_CACHE_PREFIX + token;
return redisUtil.delete(cacheKey);
} catch (Exception e) {
return false;
}
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/utils/JwtTokenUtil.java | Java | unknown | 3,019 |
package com.rahms.server.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* Redis工具类
*/
@Component
public class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* 设置缓存
*/
public void set(String key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 设置缓存并指定过期时间
*/
public void set(String key, Object value, long timeout, TimeUnit unit) {
redisTemplate.opsForValue().set(key, value, timeout, unit);
}
/**
* 获取缓存
*/
public Object get(String key) {
return redisTemplate.opsForValue().get(key);
}
/**
* 获取指定类型的缓存
*/
@SuppressWarnings("unchecked")
public <T> T get(String key, Class<T> clazz) {
Object value = redisTemplate.opsForValue().get(key);
if (value != null && clazz.isInstance(value)) {
return (T) value;
}
return null;
}
/**
* 删除缓存
*/
public boolean delete(String key) {
return Boolean.TRUE.equals(redisTemplate.delete(key));
}
/**
* 判断key是否存在
*/
public boolean hasKey(String key) {
return Boolean.TRUE.equals(redisTemplate.hasKey(key));
}
/**
* 设置过期时间
*/
public boolean expire(String key, long timeout, TimeUnit unit) {
return Boolean.TRUE.equals(redisTemplate.expire(key, timeout, unit));
}
/**
* 获取过期时间
*/
public long getExpire(String key) {
Long expire = redisTemplate.getExpire(key);
return expire != null ? expire : -1;
}
/**
* 递增
*/
public long increment(String key) {
Long result = redisTemplate.opsForValue().increment(key);
return result != null ? result : 0;
}
/**
* 递减
*/
public long decrement(String key) {
Long result = redisTemplate.opsForValue().decrement(key);
return result != null ? result : 0;
}
/**
* 设置Hash缓存
*/
public void hSet(String key, String field, Object value) {
redisTemplate.opsForHash().put(key, field, value);
}
/**
* 获取Hash缓存
*/
public Object hGet(String key, String field) {
return redisTemplate.opsForHash().get(key, field);
}
/**
* 删除Hash缓存
*/
public boolean hDelete(String key, String field) {
return redisTemplate.opsForHash().delete(key, field) > 0;
}
/**
* 判断Hash中是否存在field
*/
public boolean hHasKey(String key, String field) {
return redisTemplate.opsForHash().hasKey(key, field);
}
}
| 2401_83195498/community_elder | server/src/main/java/com/rahms/server/utils/RedisUtil.java | Java | unknown | 2,916 |
module.exports = {
presets: [
'@vue/cli-plugin-babel/preset'
]
}
| 2401_83195498/community_elder | web/babel.config.js | JavaScript | unknown | 73 |
<!DOCTYPE html>
<html lang="">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<link rel="icon" href="<%= BASE_URL %>favicon.ico">
<title><%= htmlWebpackPlugin.options.title %></title>
</head>
<body>
<noscript>
<strong>We're sorry but <%= htmlWebpackPlugin.options.title %> doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
</noscript>
<div id="app"></div>
<!-- built files will be auto injected -->
</body>
</html>
| 2401_83195498/community_elder | web/public/index.html | HTML | unknown | 611 |
<template>
<img alt="Vue logo" src="./assets/logo.png">
<HelloWorld msg="Welcome to Your Vue.js App"/>
</template>
<script>
import HelloWorld from './components/HelloWorld.vue'
export default {
name: 'App',
components: {
HelloWorld
}
}
</script>
<style>
#app {
font-family: Avenir, Helvetica, Arial, sans-serif;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
text-align: center;
color: #2c3e50;
margin-top: 60px;
}
</style>
| 2401_83195498/community_elder | web/src/App.vue | Vue | unknown | 479 |
<template>
<div class="hello">
<h1>{{ msg }}</h1>
<p>
For a guide and recipes on how to configure / customize this project,<br>
check out the
<a href="https://cli.vuejs.org" target="_blank" rel="noopener">vue-cli documentation</a>.
</p>
<h3>Installed CLI Plugins</h3>
<ul>
<li><a href="https://github.com/vuejs/vue-cli/tree/dev/packages/%40vue/cli-plugin-babel" target="_blank" rel="noopener">babel</a></li>
<li><a href="https://github.com/vuejs/vue-cli/tree/dev/packages/%40vue/cli-plugin-eslint" target="_blank" rel="noopener">eslint</a></li>
</ul>
<h3>Essential Links</h3>
<ul>
<li><a href="https://vuejs.org" target="_blank" rel="noopener">Core Docs</a></li>
<li><a href="https://forum.vuejs.org" target="_blank" rel="noopener">Forum</a></li>
<li><a href="https://chat.vuejs.org" target="_blank" rel="noopener">Community Chat</a></li>
<li><a href="https://twitter.com/vuejs" target="_blank" rel="noopener">Twitter</a></li>
<li><a href="https://news.vuejs.org" target="_blank" rel="noopener">News</a></li>
</ul>
<h3>Ecosystem</h3>
<ul>
<li><a href="https://router.vuejs.org" target="_blank" rel="noopener">vue-router</a></li>
<li><a href="https://vuex.vuejs.org" target="_blank" rel="noopener">vuex</a></li>
<li><a href="https://github.com/vuejs/vue-devtools#vue-devtools" target="_blank" rel="noopener">vue-devtools</a></li>
<li><a href="https://vue-loader.vuejs.org" target="_blank" rel="noopener">vue-loader</a></li>
<li><a href="https://github.com/vuejs/awesome-vue" target="_blank" rel="noopener">awesome-vue</a></li>
</ul>
</div>
</template>
<script>
export default {
name: 'HelloWorld',
props: {
msg: String
}
}
</script>
<!-- Add "scoped" attribute to limit CSS to this component only -->
<style scoped>
h3 {
margin: 40px 0 0;
}
ul {
list-style-type: none;
padding: 0;
}
li {
display: inline-block;
margin: 0 10px;
}
a {
color: #42b983;
}
</style>
| 2401_83195498/community_elder | web/src/components/HelloWorld.vue | Vue | unknown | 2,025 |
import { createApp } from 'vue'
import App from './App.vue'
createApp(App).mount('#app')
| 2401_83195498/community_elder | web/src/main.js | JavaScript | unknown | 90 |
const { defineConfig } = require('@vue/cli-service')
module.exports = defineConfig({
transpileDependencies: true
})
| 2401_83195498/community_elder | web/vue.config.js | JavaScript | unknown | 118 |
<!DOCTYPE html>
<html lang="">
<head>
<meta charset="UTF-8">
<link rel="icon" href="/favicon.ico">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Vite App</title>
<script type="module" crossorigin src="/assets/index-Pp7rpT7e.js"></script>
<link rel="stylesheet" crossorigin href="/assets/index--c73KgsH.css">
</head>
<body>
<div id="app"></div>
</body>
</html> | 2301_77622302/my_web_page | index.html | HTML | unknown | 427 |
<script>
export default {
onLaunch: function() {
console.log('App Launch')
},
onShow: function() {
console.log('App Show')
},
onHide: function() {
console.log('App Hide')
}
}
</script>
<style>
/*每个页面公共css */
</style>
| 2401_83208066/demo | App.vue | Vue | unknown | 254 |
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<script>
var coverSupport = 'CSS' in window && typeof CSS.supports === 'function' && (CSS.supports('top: env(a)') ||
CSS.supports('top: constant(a)'))
document.write(
'<meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0' +
(coverSupport ? ', viewport-fit=cover' : '') + '" />')
</script>
<title></title>
<!--preload-links-->
<!--app-context-->
</head>
<body>
<div id="app"><!--app-html--></div>
<script type="module" src="/main.js"></script>
</body>
</html>
| 2401_83208066/demo | index.html | HTML | unknown | 675 |
import App from './App'
// #ifndef VUE3
import Vue from 'vue'
import './uni.promisify.adaptor'
Vue.config.productionTip = false
App.mpType = 'app'
const app = new Vue({
...App
})
app.$mount()
// #endif
// #ifdef VUE3
import { createSSRApp } from 'vue'
export function createApp() {
const app = createSSRApp(App)
return {
app
}
}
// #endif | 2401_83208066/demo | main.js | JavaScript | unknown | 352 |
<template>
<view class="content">
<image class="logo" src="/static/logo.png"></image>
<view class="text-area">
<text class="title">{{title}}</text>
</view>
</view>
</template>
<script>
export default {
data() {
return {
title: 'Hello'
}
},
onLoad() {
},
methods: {
}
}
</script>
<style>
.content {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
}
.logo {
height: 200rpx;
width: 200rpx;
margin-top: 200rpx;
margin-left: auto;
margin-right: auto;
margin-bottom: 50rpx;
}
.text-area {
display: flex;
justify-content: center;
}
.title {
font-size: 36rpx;
color: #8f8f94;
}
</style>
| 2401_83208066/demo | pages/index/index.vue | Vue | unknown | 694 |
uni.addInterceptor({
returnValue (res) {
if (!(!!res && (typeof res === "object" || typeof res === "function") && typeof res.then === "function")) {
return res;
}
return new Promise((resolve, reject) => {
res.then((res) => {
if (!res) return resolve(res)
return res[0] ? reject(res[0]) : resolve(res[1])
});
});
},
}); | 2401_83208066/demo | uni.promisify.adaptor.js | JavaScript | unknown | 373 |