From 7a18db21235514356357fd37c6cc24fc463f423b Mon Sep 17 00:00:00 2001 From: WangLX <519407855@qq.com> Date: Fri, 18 Sep 2026 17:27:58 +0800 Subject: [PATCH] feat: add model groups, verified registration and CNY credit grants --- control-plane-java/pom.xml | 9 + .../moyi/controlplane/HealthController.java | 7 +- .../controlplane/auth/AuthController.java | 21 +- .../moyi/controlplane/auth/AuthService.java | 19 ++ .../auth/CloudVerificationSender.java | 63 ++++ .../controlplane/auth/VerificationSender.java | 6 + .../auth/VerificationService.java | 69 +++++ .../catalog/CatalogController.java | 25 +- .../controlplane/catalog/CatalogService.java | 154 +++++++++- .../controlplane/wallet/WalletController.java | 23 ++ .../controlplane/wallet/WalletService.java | 60 ++++ ...model_definitions_wallets_verification.sql | 58 ++++ .../PlatformAdminPostgresTest.java | 202 +++++++++++++ .../controlplane/auth/AuthPostgresTest.java | 2 +- .../auth/PasswordHasherInteropTest.java | 18 ++ docs/11-server-test-deployment.md | 23 ++ docs/13-model-groups-registration-credit.md | 76 +++++ infra/moyi/.env.cloud.example | 17 ++ infra/moyi/admin_credentials.py | 278 ++++++++++++++++++ infra/moyi/backup_database.py | 79 +++++ infra/moyi/docker-compose.cloud.yml | 11 + infra/moyi/nginx/routes.conf | 2 + infra/moyi/tests/test_admin_credentials.py | 246 ++++++++++++++++ infra/moyi/tests/test_backup_database.py | 66 +++++ infra/moyi/tests/test_deploy.py | 6 + prototype/nginx.conf | 6 +- prototype/src/App.vue | 10 +- prototype/src/components/AccountAdmin.vue | 106 +++++++ prototype/src/components/CatalogAdmin.vue | 151 ++++++++++ .../src/components/ModelGroupPermissions.vue | 48 +++ prototype/src/components/SlidePanel.vue | 2 +- prototype/src/components/UiModal.vue | 4 +- prototype/src/data.ts | 4 +- prototype/src/services/auth.ts | 13 + prototype/src/services/catalog.ts | 55 +++- prototype/src/types.ts | 1 + prototype/src/views/AdminConsole.vue | 214 +------------- prototype/src/views/AuthView.vue | 30 +- prototype/src/views/UserConsole.vue | 57 ++-- scripts/package-deployment.ps1 | 2 +- 40 files changed, 1980 insertions(+), 263 deletions(-) create mode 100644 control-plane-java/src/main/java/com/moyi/controlplane/auth/CloudVerificationSender.java create mode 100644 control-plane-java/src/main/java/com/moyi/controlplane/auth/VerificationSender.java create mode 100644 control-plane-java/src/main/java/com/moyi/controlplane/auth/VerificationService.java create mode 100644 control-plane-java/src/main/java/com/moyi/controlplane/wallet/WalletController.java create mode 100644 control-plane-java/src/main/java/com/moyi/controlplane/wallet/WalletService.java create mode 100644 control-plane-java/src/main/resources/db/migration/V10__model_definitions_wallets_verification.sql create mode 100644 control-plane-java/src/test/java/com/moyi/controlplane/PlatformAdminPostgresTest.java create mode 100644 control-plane-java/src/test/java/com/moyi/controlplane/auth/PasswordHasherInteropTest.java create mode 100644 docs/13-model-groups-registration-credit.md create mode 100644 infra/moyi/admin_credentials.py create mode 100644 infra/moyi/backup_database.py create mode 100644 infra/moyi/tests/test_admin_credentials.py create mode 100644 infra/moyi/tests/test_backup_database.py create mode 100644 prototype/src/components/AccountAdmin.vue create mode 100644 prototype/src/components/CatalogAdmin.vue create mode 100644 prototype/src/components/ModelGroupPermissions.vue diff --git a/control-plane-java/pom.xml b/control-plane-java/pom.xml index 98a63f8..1d542c6 100644 --- a/control-plane-java/pom.xml +++ b/control-plane-java/pom.xml @@ -20,6 +20,15 @@ + + org.springframework.boot + spring-boot-starter-mail + + + com.aliyun + dysmsapi20170525 + 4.6.0 + org.springframework.boot spring-boot-starter-web diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/HealthController.java b/control-plane-java/src/main/java/com/moyi/controlplane/HealthController.java index 2ddcbfe..2a57d5e 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/HealthController.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/HealthController.java @@ -6,6 +6,11 @@ import org.springframework.web.bind.annotation.RestController; @RestController public class HealthController { + private final com.moyi.controlplane.auth.VerificationService verification; + + public HealthController(com.moyi.controlplane.auth.VerificationService verification) { + this.verification = verification; + } @GetMapping("/health") public Map health() { return Map.of( @@ -13,7 +18,7 @@ public class HealthController { "service", "moyi-control-plane-java", "migration", "catalog", "capabilities", Map.of( - "verificationCode", false, + "verificationCode", verification.capabilities().containsValue(true), "passwordReset", false ) ); diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthController.java b/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthController.java index e45d224..5b2bea5 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthController.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthController.java @@ -26,26 +26,44 @@ import org.springframework.web.bind.annotation.RestController; public class AuthController { private static final String SESSION_COOKIE = "moyi_session"; private final AuthService authService; + private final VerificationService verification; private final int sessionTtlHours; private final boolean secureCookie; public AuthController( AuthService authService, + VerificationService verification, @Value("${moyi.auth.session-ttl-hours}") int sessionTtlHours, @Value("${moyi.auth.secure-cookie}") boolean secureCookie ) { this.authService = authService; + this.verification = verification; this.sessionTtlHours = sessionTtlHours; this.secureCookie = secureCookie; } public record LoginRequest(String account, String password) {} - public record RegisterRequest(String invitationCode, String account, String password, String displayName) {} + public record RegisterRequest(String invitationCode, String account, String password, String displayName, String verificationCode) {} + public record CodeRequest(String account, String invitationCode) {} + + @GetMapping("/auth/verification") + public Map verificationStatus() { return verification.capabilities(); } + + @PostMapping("/auth/verification") + public Map sendCode(@RequestBody CodeRequest input,HttpServletRequest request) { + return verification.send(input.account(),input.invitationCode(),request.getRemoteAddr()); + } public record InvitationRequest(String label, Integer maxUses, OffsetDateTime expiresAt) {} public record RoleRequest(String role) {} + public record CreateUserRequest(String account, String password, String displayName) {} + + @PostMapping("/admin/users") + public ResponseEntity> createUser(@RequestBody CreateUserRequest input, HttpServletRequest request) { + return ResponseEntity.status(HttpStatus.CREATED).body(Map.of("user",authService.createUser(sessionToken(request),input.account(),input.password(),input.displayName(),meta(request)))); + } @PostMapping("/auth/login") public Map login( @@ -64,6 +82,7 @@ public class AuthController { HttpServletRequest request, HttpServletResponse response ) { + verification.consume(input.account(),input.verificationCode()); AuthService.AuthResult result = authService.register( input.invitationCode(), input.account(), input.password(), input.displayName(), meta(request) ); diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthService.java b/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthService.java index bc6e1d7..6411139 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthService.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthService.java @@ -234,6 +234,25 @@ public class AuthService { return jdbc.query("SELECT * FROM users ORDER BY created_at DESC", this::mapUser).stream().map(user -> toView(user, null)).toList(); } + @Transactional + public UserView createUser(String token, String accountInput, String password, String displayName, RequestMeta meta) { + UserView actor=requireAdmin(token); + String account=normalizeAccount(accountInput); + if(account.isBlank() || account.length()>254 || (!EMAIL.matcher(account).matches() && !PHONE.matcher(account).matches() && !account.matches("[a-z0-9_]{3,64}"))) throw new ApiException("INVALID_ACCOUNT","请输入有效邮箱、手机号或 3 至 64 位字母数字下划线用户名"); + if(password==null || password.length()<8 || password.length()>256) throw new ApiException("WEAK_PASSWORD","普通用户密码长度为 8 至 256 位"); + if(findUserByAccount(account)!=null) throw new ApiException("ACCOUNT_EXISTS","账号已存在",409); + String name=displayName==null || displayName.isBlank()?defaultDisplayName(account):displayName.trim(); + if(name.length()>80) throw new ApiException("INVALID_NAME","显示名称最多 80 字符"); + UUID id=UUID.randomUUID(); + jdbc.update("INSERT INTO users(id,account,account_kind,password_hash,display_name,role,status) VALUES (?,?,?,?,?,'user','active')",id,account,accountKind(account),passwordHasher.hash(password),name); + authCreatedAudit(actor.id(),id,meta); + return toView(findUserById(id),null); + } + + private void authCreatedAudit(UUID actor, UUID user, RequestMeta meta) { + audit("user.admin_created",actor,meta,Map.of("targetUserId",user)); + } + @Transactional public Map createInvitation( String token, diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/auth/CloudVerificationSender.java b/control-plane-java/src/main/java/com/moyi/controlplane/auth/CloudVerificationSender.java new file mode 100644 index 0000000..1a17273 --- /dev/null +++ b/control-plane-java/src/main/java/com/moyi/controlplane/auth/CloudVerificationSender.java @@ -0,0 +1,63 @@ +package com.moyi.controlplane.auth; + +import com.aliyun.dysmsapi20170525.models.SendSmsRequest; +import com.aliyun.teaopenapi.models.Config; +import com.aliyun.teautil.models.RuntimeOptions; +import com.moyi.controlplane.common.ApiException; +import org.springframework.core.env.Environment; +import org.springframework.mail.SimpleMailMessage; +import org.springframework.mail.javamail.JavaMailSenderImpl; +import org.springframework.stereotype.Component; + +@Component +public class CloudVerificationSender implements VerificationSender { + private final Environment env; + public CloudVerificationSender(Environment env) { this.env=env; } + private String value(String key) { return env.getProperty(key,"").trim(); } + + @Override + public boolean available(String channel) { + if("email".equals(channel)) return !value("MOYI_SMTP_HOST").isEmpty() && !value("MOYI_SMTP_FROM").isEmpty(); + return !value("MOYI_SMS_ACCESS_KEY_ID").isEmpty() && !value("MOYI_SMS_ACCESS_KEY_SECRET").isEmpty() && !value("MOYI_SMS_SIGN_NAME").isEmpty() && !value("MOYI_SMS_TEMPLATE_CODE").isEmpty(); + } + + @Override + public void send(String channel,String account,String code) { + if(!available(channel)) throw new ApiException("VERIFICATION_UNAVAILABLE","该验证码发送服务尚未配置,请联系管理员",503); + try { + if("email".equals(channel)) { + JavaMailSenderImpl mail=new JavaMailSenderImpl(); + mail.setHost(value("MOYI_SMTP_HOST")); + mail.setPort(env.getProperty("MOYI_SMTP_PORT",Integer.class,465)); + mail.setUsername(value("MOYI_SMTP_USERNAME")); + mail.setPassword(env.getProperty("MOYI_SMTP_PASSWORD","")); + mail.setDefaultEncoding("UTF-8"); + var properties=mail.getJavaMailProperties(); + properties.setProperty("mail.smtp.auth",String.valueOf(!value("MOYI_SMTP_USERNAME").isEmpty())); + properties.setProperty("mail.smtp.ssl.enable",env.getProperty("MOYI_SMTP_SSL","true")); + properties.setProperty("mail.smtp.starttls.enable",env.getProperty("MOYI_SMTP_STARTTLS","false")); + properties.setProperty("mail.smtp.starttls.required",env.getProperty("MOYI_SMTP_STARTTLS","false")); + properties.setProperty("mail.smtp.ssl.checkserveridentity","true"); + properties.setProperty("mail.smtp.connectiontimeout","5000"); + properties.setProperty("mail.smtp.timeout","10000"); + properties.setProperty("mail.smtp.writetimeout","10000"); + SimpleMailMessage message=new SimpleMailMessage(); + message.setFrom(value("MOYI_SMTP_FROM")); + message.setTo(account); + message.setSubject("MOYI 注册验证码"); + message.setText("您的注册验证码为:"+code+",5 分钟内有效。请勿向他人泄露。若非本人操作,请忽略此邮件。"); + mail.send(message); + } else { + Config config=new Config().setAccessKeyId(value("MOYI_SMS_ACCESS_KEY_ID")).setAccessKeySecret(value("MOYI_SMS_ACCESS_KEY_SECRET")).setEndpoint("dysmsapi.aliyuncs.com").setProtocol("https"); + var client=new com.aliyun.dysmsapi20170525.Client(config); + var request=new SendSmsRequest().setPhoneNumbers(account.startsWith("+86")?account.substring(3):account) + .setSignName(value("MOYI_SMS_SIGN_NAME")).setTemplateCode(value("MOYI_SMS_TEMPLATE_CODE")).setTemplateParam("{\"code\":\""+code+"\"}"); + var response=client.sendSmsWithOptions(request,new RuntimeOptions().setAutoretry(false).setConnectTimeout(5000).setReadTimeout(10000)); + if(response.getBody()==null || !"OK".equals(response.getBody().getCode())) throw new IllegalStateException("SMS rejected"); + } + } catch(Exception exception) { + // SDK exceptions may contain credentials or recipients. Never expose them to logs or clients. + throw new ApiException("VERIFICATION_SEND_FAILED","验证码发送失败,请稍后重试或联系管理员检查发送服务",502); + } + } +} diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/auth/VerificationSender.java b/control-plane-java/src/main/java/com/moyi/controlplane/auth/VerificationSender.java new file mode 100644 index 0000000..bdf0cd9 --- /dev/null +++ b/control-plane-java/src/main/java/com/moyi/controlplane/auth/VerificationSender.java @@ -0,0 +1,6 @@ +package com.moyi.controlplane.auth; + +public interface VerificationSender { + boolean available(String channel); + void send(String channel, String account, String code); +} diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/auth/VerificationService.java b/control-plane-java/src/main/java/com/moyi/controlplane/auth/VerificationService.java new file mode 100644 index 0000000..86681b6 --- /dev/null +++ b/control-plane-java/src/main/java/com/moyi/controlplane/auth/VerificationService.java @@ -0,0 +1,69 @@ +package com.moyi.controlplane.auth; + +import com.moyi.controlplane.common.ApiException; +import java.security.MessageDigest; +import java.security.SecureRandom; +import java.nio.charset.StandardCharsets; +import java.time.OffsetDateTime; +import java.util.Locale; +import java.util.Map; +import java.util.UUID; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +public class VerificationService { + private final JdbcTemplate jdbc; + private final VerificationSender sender; + private final String pepper; + private final SecureRandom random=new SecureRandom(); + public VerificationService(JdbcTemplate jdbc,VerificationSender sender,@Value("${moyi.auth.password-pepper}") String pepper) { + this.jdbc=jdbc; this.sender=sender; this.pepper=pepper; + } + public Map capabilities() { return Map.of("email",sender.available("email"),"phone",sender.available("phone")); } + public String normalize(String raw) { + String account=raw==null?"":raw.trim().toLowerCase(Locale.ROOT); + if(!account.contains("@")) account=account.replaceAll("[\\s-]",""); + if(account.length()>254 || (!account.matches("^[^\\s@,;<>]+@[^\\s@,;<>]+\\.[^\\s@,;<>]+$") && !account.matches("^(?:\\+86)?1[3-9][0-9]{9}$"))) throw new ApiException("INVALID_ACCOUNT","请输入有效邮箱或中国大陆手机号"); + return account; + } + private String digest(String account,String code) { return AuthService.hashSecret(pepper+":registration:"+account+":"+code); } + + @Transactional(noRollbackFor=ApiException.class) + public Map send(String raw,String invitation,String ip) { + String account=normalize(raw), channel=account.contains("@")?"email":"phone"; + if(!sender.available(channel)) throw new ApiException("VERIFICATION_UNAVAILABLE","该验证码发送服务尚未配置,请联系管理员",503); + Integer invites=jdbc.queryForObject("SELECT count(*) FROM invitation_codes WHERE code_hash=? AND disabled_at IS NULL AND used_countnow())",Integer.class,AuthService.hashSecret(invitation==null?"":invitation.trim())); + if(invites==null || invites==0) throw new ApiException("INVITATION_INVALID","请先填写有效邀请码",403); + String source=ip==null?"unknown":ip; + // One global lock bounds aggregate sending and serializes account/IP limits across replicas. + jdbc.queryForList("SELECT pg_advisory_xact_lock(734092615)"); + Integer limited=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account=? AND created_at>now()-interval '60 seconds'",Integer.class,account); + Integer daily=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account=? AND created_at>now()-interval '24 hours'",Integer.class,account); + Integer hourly=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE ip_address=? AND created_at>now()-interval '1 hour'",Integer.class,source); + Integer total=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE created_at>now()-interval '24 hours'",Integer.class); + if(limited>0 || daily>=10 || hourly>=30 || total>=1000) throw new ApiException("VERIFICATION_RATE_LIMIT","发送过于频繁,请稍后重试",429); + String code=String.format(Locale.ROOT,"%06d",random.nextInt(1000000)); + jdbc.update("INSERT INTO verification_send_events(id,account,ip_address) VALUES (?,?,?)",UUID.randomUUID(),account,source); + jdbc.update("INSERT INTO registration_codes(account,code_hash,expires_at) VALUES (?,?,now()+interval '5 minutes') ON CONFLICT(account) DO UPDATE SET code_hash=excluded.code_hash, expires_at=excluded.expires_at, attempts=0, consumed=false, created_at=now()",account,digest(account,code)); + try { sender.send(channel,account,code); } + catch(ApiException exception) { jdbc.update("UPDATE registration_codes SET consumed=true WHERE account=?",account); throw exception; } + jdbc.update("DELETE FROM verification_send_events WHERE created_at=5) throw new ApiException("VERIFICATION_EXPIRED","验证码已失效,请重新获取"); + jdbc.update("UPDATE registration_codes SET attempts=attempts+1 WHERE account=?",account); + if(code==null || !code.matches("[0-9]{6}") || !MessageDigest.isEqual(String.valueOf(row.get("code_hash")).getBytes(StandardCharsets.UTF_8),digest(account,code).getBytes(StandardCharsets.UTF_8))) throw new ApiException("VERIFICATION_INVALID","验证码错误"); + jdbc.update("UPDATE registration_codes SET consumed=true WHERE account=?",account); + } +} diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/catalog/CatalogController.java b/control-plane-java/src/main/java/com/moyi/controlplane/catalog/CatalogController.java index 2be7d9b..06bf4ed 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/catalog/CatalogController.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/catalog/CatalogController.java @@ -8,6 +8,7 @@ import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PatchMapping; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestHeader; @@ -28,7 +29,7 @@ public class CatalogController { @GetMapping("/models") public Map models(jakarta.servlet.http.HttpServletRequest request) { authService.requireUser(AuthController.sessionToken(request)); - return Map.of("providers", catalogService.listProviders(false), "models", catalogService.listModels(false)); + return Map.of("providers", catalogService.listProviders(false), "models", catalogService.listModels(false), "logicalModels", catalogService.listDefinitions(false)); } @GetMapping("/overview") @@ -103,7 +104,27 @@ public class CatalogController { @GetMapping("/admin/models") public Map adminModels(jakarta.servlet.http.HttpServletRequest request) { authService.requireAdmin(AuthController.sessionToken(request)); - return Map.of("models", catalogService.listModels(true)); + return Map.of("models", catalogService.listModels(true), "logicalModels", catalogService.listDefinitions(true)); + } + + @PatchMapping("/admin/providers/{id}") + public Map updateProvider(@PathVariable String id, @RequestBody Map input, jakarta.servlet.http.HttpServletRequest request) { + return Map.of("provider",catalogService.updateProvider(id,input,AuthController.sessionToken(request),authService)); + } + + @PatchMapping("/admin/models/{id}") + public Map updateGroup(@PathVariable String id, @RequestBody Map input, jakarta.servlet.http.HttpServletRequest request) { + return Map.of("model",catalogService.updateModel(id,input,AuthController.sessionToken(request),authService)); + } + + @PostMapping("/admin/model-definitions") + public ResponseEntity> createDefinition(@RequestBody Map input, jakarta.servlet.http.HttpServletRequest request) { + return ResponseEntity.status(HttpStatus.CREATED).body(Map.of("model",catalogService.saveDefinition(null,input,AuthController.sessionToken(request),authService))); + } + + @PatchMapping("/admin/model-definitions/{id}") + public Map updateDefinition(@PathVariable String id, @RequestBody Map input, jakarta.servlet.http.HttpServletRequest request) { + return Map.of("model",catalogService.saveDefinition(id,input,AuthController.sessionToken(request),authService)); } @PostMapping("/admin/models") diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/catalog/CatalogService.java b/control-plane-java/src/main/java/com/moyi/controlplane/catalog/CatalogService.java index c112ead..828cc5f 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/catalog/CatalogService.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/catalog/CatalogService.java @@ -48,8 +48,56 @@ public class CatalogService { } public List> listModels(boolean includeDisabled) { - String statusClause = includeDisabled ? "" : " WHERE status = 'active'"; - return jdbc.query("SELECT * FROM model_catalog" + statusClause + " ORDER BY public_name", this::mapModel); + String statusClause = includeDisabled ? "" : " WHERE m.status = 'active' AND p.status = 'active' AND d.status = 'active'"; + return jdbc.query("SELECT m.* FROM model_catalog m JOIN model_providers p ON p.id=m.provider_id JOIN model_definitions d ON d.id=m.logical_model_id" + statusClause + " ORDER BY m.public_name, m.source_label", this::mapModel); + } + + public List> listDefinitions(boolean includeDisabled) { + return jdbc.query("SELECT * FROM model_definitions" + (includeDisabled ? "" : " WHERE status='active'") + " ORDER BY public_name", (rs, n) -> { + Map item = new LinkedHashMap<>(); + item.put("id", rs.getString("id")); + item.put("publicName", rs.getString("public_name")); + item.put("modelKey", rs.getString("model_key")); + item.put("type", rs.getString("model_type")); + item.put("mode", rs.getString("call_mode")); + item.put("description", rs.getString("description")); + item.put("inputTypes", readList(rs.getString("input_types"))); + item.put("outputTypes", readList(rs.getString("output_types"))); + item.put("status", rs.getString("status")); + return item; + }); + } + + @Transactional + public Map saveDefinition(String id, Map input, String token, AuthService auth) { + UserView admin = auth.requireAdmin(token); + boolean creating = id == null; + Map value = creating ? new LinkedHashMap<>() : new LinkedHashMap<>(definition(id)); + value.putAll(input); + String name = required(value, "publicName"); + String type = required(value, "type"); + String mode = required(value, "mode"); + String status = status(value); + if (name.length() > 160 || !MODEL_TYPES.contains(type) || !CALL_MODES.contains(mode)) throw new ApiException("INVALID_MODEL", "模型名称、类型或调用模式无效"); + if (creating) { + id = UUID.randomUUID().toString(); + jdbc.update("INSERT INTO model_definitions (id, model_key, public_name, model_type, call_mode, description, input_types, output_types, status) VALUES (?, ?, ?, ?, ?, ?, CAST(? AS jsonb), CAST(? AS jsonb), ?)", id, optional(value, "modelKey", null), name, type, mode, optional(value, "description", ""), jsonArray(value.get("inputTypes")), jsonArray(value.get("outputTypes")), status); + } else { + jdbc.update("UPDATE model_definitions SET model_key=?, public_name=?, model_type=?, call_mode=?, description=?, input_types=CAST(? AS jsonb), output_types=CAST(? AS jsonb), status=?, updated_at=now() WHERE id=?", optional(value,"modelKey",null), name, type, mode, optional(value,"description",""), jsonArray(value.get("inputTypes")), jsonArray(value.get("outputTypes")), status, id); + jdbc.update("UPDATE model_catalog SET model_key=?, public_name=?, model_type=?, call_mode=?, description=?, input_types=CAST(? AS jsonb), output_types=CAST(? AS jsonb), updated_at=now() WHERE logical_model_id=?", optional(value,"modelKey",null), name, type, mode, optional(value,"description",""), jsonArray(value.get("inputTypes")), jsonArray(value.get("outputTypes")), id); + } + auth.audit(creating ? "model_definition.created" : "model_definition.updated", admin.id(), new AuthService.RequestMeta(null,null), Map.of("modelId",id)); + return definition(id); + } + + private Map definition(String id) { + return listDefinitions(true).stream().filter(item -> id.equals(item.get("id"))).findFirst().orElseThrow(() -> new ApiException("MODEL_NOT_FOUND", "模型不存在", 404)); + } + + private String status(Map input) { + String value = optional(input,"status","active"); + if (!List.of("active","disabled").contains(value)) throw new ApiException("INVALID_STATUS", "状态无效"); + return value; } @Transactional @@ -59,54 +107,123 @@ public class CatalogService { String name = required(input, "name"); String protocol = optional(input, "protocol", "http"); String sourceType = optional(input, "sourceType", "custom"); - if (!code.matches("^[a-z0-9][a-z0-9._-]{1,63}$") || !PROTOCOLS.contains(protocol) || !SOURCE_TYPES.contains(sourceType)) { + if (!code.matches("^[a-z0-9][a-z0-9._-]{1,63}$") || name.length() > 120 || !PROTOCOLS.contains(protocol) || !SOURCE_TYPES.contains(sourceType)) { throw new ApiException("INVALID_PROVIDER", "供应商标识、协议或来源类型无效"); } String id = UUID.randomUUID().toString(); String baseUrl = optional(input, "baseUrl", null); + validateBaseUrl(baseUrl); String description = optional(input, "description", ""); - String credentialType = optional(input, "credentialType", null); - String secret = optional(input, "credentialSecret", null); + String credentialType = optional(input, "credentialType", "none"); + if (!List.of("none", "api-key", "bearer", "access-token").contains(credentialType)) throw new ApiException("INVALID_CREDENTIAL_TYPE", "凭据类型无效"); + String secret = "none".equals(credentialType) ? null : optional(input, "credentialSecret", null); String masked = secret == null ? null : mask(secret); jdbc.update( - "INSERT INTO model_providers (id, code, name, protocol, source_type, base_url, description, credential_type, credential_ciphertext, credential_masked, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active')", - id, code, name, protocol, sourceType, baseUrl, description, credentialType, secret == null ? null : secretCipher.encrypt(secret), masked + "INSERT INTO model_providers (id, code, name, protocol, source_type, base_url, description, credential_type, credential_ciphertext, credential_masked, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + id, code, name, protocol, sourceType, baseUrl, description, credentialType, secret == null ? null : secretCipher.encrypt(secret), masked, status(input) ); auth.audit("provider.created", admin.id(), new AuthService.RequestMeta(null, null), Map.of("providerId", id)); return findProvider(id); } + @Transactional + public Map updateProvider(String id, Map input, String token, AuthService auth) { + UserView admin = auth.requireAdmin(token); + Map previous = findProvider(id); + if (previous == null) throw new ApiException("PROVIDER_NOT_FOUND", "渠道不存在", 404); + Map value = new LinkedHashMap<>(previous); + value.putAll(input); + String code=required(value,"code").toLowerCase(), name=required(value,"name"), protocol=required(value,"protocol"), sourceType=required(value,"sourceType"); + if (!code.matches("^[a-z0-9][a-z0-9._-]{1,63}$") || name.length()>120 || !PROTOCOLS.contains(protocol) || !SOURCE_TYPES.contains(sourceType)) throw new ApiException("INVALID_PROVIDER", "渠道标识、名称、协议或类型无效"); + String baseUrl=optional(value,"baseUrl",null); + validateBaseUrl(baseUrl); + String credentialType=optional(value,"credentialType","none"); + if (!List.of("none","api-key","bearer","access-token").contains(credentialType)) throw new ApiException("INVALID_CREDENTIAL_TYPE","凭据类型无效"); + jdbc.update("UPDATE model_providers SET code=?, name=?, protocol=?, source_type=?, base_url=?, description=?, credential_type=?, status=?, updated_at=now() WHERE id=?", code,name,protocol,sourceType,baseUrl,optional(value,"description",""),credentialType,status(value),id); + String secret=optional(input,"credentialSecret",""); + if ("none".equals(credentialType)) jdbc.update("UPDATE model_providers SET credential_ciphertext=NULL, credential_masked=NULL WHERE id=?",id); + else if (!secret.isBlank()) jdbc.update("UPDATE model_providers SET credential_ciphertext=?, credential_masked=? WHERE id=?",secretCipher.encrypt(secret),mask(secret),id); + auth.audit("provider.updated",admin.id(),new AuthService.RequestMeta(null,null),Map.of("providerId",id)); + return findProvider(id); + } + + private void validateBaseUrl(String value) { + if (value == null || value.isBlank()) return; + try { + java.net.URI uri=java.net.URI.create(value); + if (!List.of("https","http").contains(uri.getScheme()) || uri.getHost()==null || uri.getUserInfo()!=null || uri.getQuery()!=null || uri.getFragment()!=null) throw new IllegalArgumentException(); + } catch (IllegalArgumentException exception) { throw new ApiException("INVALID_BASE_URL","Base URL 必须是 HTTP(S) 地址,不能包含密码、查询参数或片段"); } + } + @Transactional public Map createModel(Map input, String token, AuthService auth) { UserView admin = auth.requireAdmin(token); + input = new LinkedHashMap<>(input); + String logicalId = optional(input, "logicalModelId", null); + if (logicalId == null) logicalId = String.valueOf(saveDefinition(null, input, token, auth).get("id")); + Map definition = definition(logicalId); + for (String field : List.of("publicName","modelKey","type","mode","description","inputTypes","outputTypes")) input.put(field,definition.get(field)); String providerId = required(input, "providerId"); if (findProvider(providerId) == null) throw new ApiException("PROVIDER_NOT_FOUND", "供应商不存在", 404); String publicName = required(input, "publicName"); String upstreamModel = required(input, "upstreamModel"); + if (upstreamModel.length() > 160) throw new ApiException("INVALID_MODEL", "上游模型标识不能超过 160 字符"); String type = required(input, "type"); String mode = required(input, "mode"); if (!MODEL_TYPES.contains(type) || !CALL_MODES.contains(mode)) throw new ApiException("INVALID_MODEL", "模型类型或调用模式无效"); String id = UUID.randomUUID().toString(); String modelKey = optional(input, "modelKey", null); - String sourceLabel = optional(input, "sourceLabel", null); + String sourceLabel = optional(input, "sourceLabel", "默认分组"); + if (sourceLabel.isBlank() || sourceLabel.length()>160) throw new ApiException("INVALID_GROUP_NAME","请填写分组名称(最多 160 字符)"); String description = optional(input, "description", ""); String inputTypes = jsonArray(input.get("inputTypes")); String outputTypes = jsonArray(input.get("outputTypes")); String capabilities = jsonObject(input.get("capabilities")); String pricing = jsonObjectOrNull(input.get("pricing")); + validatePricing(input.get("pricing")); Integer priority = integerOrNull(input.get("priority")); Integer maxConcurrency = integerOrNull(input.get("maxConcurrency")); if (priority != null && priority < 0) throw new ApiException("INVALID_MODEL_PRIORITY", "模型路由优先级必须大于等于 0"); - if (maxConcurrency != null && maxConcurrency < 0) throw new ApiException("INVALID_MODEL_CONCURRENCY", "模型并发上限必须大于等于 0"); + if (maxConcurrency != null && maxConcurrency < 1) throw new ApiException("INVALID_MODEL_CONCURRENCY", "模型并发上限必须大于等于 1"); jdbc.update( - "INSERT INTO model_catalog (id, provider_id, model_key, source_label, public_name, upstream_model, model_type, call_mode, description, input_types, output_types, capabilities, pricing, priority, max_concurrency, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CAST(? AS jsonb), CAST(? AS jsonb), CAST(? AS jsonb), CAST(? AS jsonb), ?, ?, 'active')", + "INSERT INTO model_catalog (id, provider_id, model_key, source_label, public_name, upstream_model, model_type, call_mode, description, input_types, output_types, capabilities, pricing, priority, max_concurrency, logical_model_id, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CAST(? AS jsonb), CAST(? AS jsonb), CAST(? AS jsonb), CAST(? AS jsonb), ?, ?, ?, ?)", id, providerId, modelKey, sourceLabel, publicName, upstreamModel, type, mode, description, - inputTypes, outputTypes, capabilities, pricing, priority, maxConcurrency + inputTypes, outputTypes, capabilities, pricing, priority, maxConcurrency, logicalId, status(input) ); auth.audit("model.created", admin.id(), new AuthService.RequestMeta(null, null), Map.of("modelId", id)); return findModel(id); } + @Transactional + public Map updateModel(String id, Map input, String token, AuthService auth) { + UserView admin=auth.requireAdmin(token); + Map old=findModel(id); + if (old==null) throw new ApiException("MODEL_NOT_FOUND","分组不存在",404); + Map value=new LinkedHashMap<>(old); + value.putAll(input); + String logicalId=required(value,"logicalModelId"); + Map definition=definition(logicalId); + String providerId=required(value,"providerId"), groupName=required(value,"sourceLabel"), upstream=required(value,"upstreamModel"); + if (findProvider(providerId)==null) throw new ApiException("PROVIDER_NOT_FOUND","渠道不存在",404); + if(groupName.length()>160 || upstream.length()>160) throw new ApiException("INVALID_MODEL","分组名称或上游标识过长"); + Integer priority=integerOrNull(value.get("priority")), concurrency=integerOrNull(value.get("maxConcurrency")); + if ((priority!=null && priority<0) || (concurrency!=null && concurrency<1)) throw new ApiException("INVALID_MODEL_LIMIT","优先级不能小于 0,并发上限至少为 1"); + validatePricing(value.get("pricing")); + jdbc.update("UPDATE model_catalog SET logical_model_id=?, provider_id=?, source_label=?, upstream_model=?, public_name=?, model_key=?, model_type=?, call_mode=?, description=?, input_types=CAST(? AS jsonb), output_types=CAST(? AS jsonb), pricing=CAST(? AS jsonb), priority=?, max_concurrency=?, status=?, updated_at=now() WHERE id=?",logicalId,providerId,groupName,upstream,definition.get("publicName"),definition.get("modelKey"),definition.get("type"),definition.get("mode"),definition.get("description"),jsonArray(definition.get("inputTypes")),jsonArray(definition.get("outputTypes")),jsonObjectOrNull(value.get("pricing")),priority,concurrency,status(value),id); + auth.audit("model_group.updated",admin.id(),new AuthService.RequestMeta(null,null),Map.of("groupId",id,"modelId",logicalId,"providerId",providerId)); + return findModel(id); + } + + private void validatePricing(Object input) { + if (!(input instanceof Map prices)) return; + for(String field: List.of("input","output")) { + Object amount=prices.get(field); + if(amount==null) continue; + try { if(new java.math.BigDecimal(String.valueOf(amount)).signum()<0) throw new NumberFormatException(); } + catch(NumberFormatException e) { throw new ApiException("INVALID_PRICE","价格必须是非负数"); } + } + } + public List> listProjects(String token, AuthService auth) { UserView user = auth.requireUser(token); return jdbc.query("SELECT * FROM model_projects WHERE owner_user_id = ? AND status = 'active' ORDER BY created_at DESC", this::mapProject, user.id()); @@ -158,8 +275,11 @@ public class CatalogService { @Transactional public Map updateKeyModels(String token, String keyId, List modelIds, AuthService auth) { UserView user = auth.requireUser(token); - List uniqueIds = modelIds == null ? List.of() : modelIds.stream().map(String::trim).filter(value -> !value.isBlank()).distinct().toList(); - for (String modelId : uniqueIds) if (findActiveModel(modelId) == null) throw new ApiException("MODEL_NOT_FOUND", "模型不存在或已下线", 404); + var existing = jdbc.query("SELECT * FROM platform_api_keys WHERE id=? AND user_id=? AND status='active' FOR UPDATE", this::mapApiKey, UUID.fromString(keyId), user.id()); + if (existing.isEmpty()) throw new ApiException("KEY_NOT_FOUND", "Key 不存在、已停用或无权修改", 404); + List priorIds = (List) existing.getFirst().get("modelIds"); + List uniqueIds = modelIds == null ? List.of() : modelIds.stream().filter(java.util.Objects::nonNull).map(String::trim).filter(value -> !value.isBlank()).distinct().toList(); + for (String modelId : uniqueIds) if (!priorIds.contains(modelId) && findActiveModel(modelId) == null) throw new ApiException("MODEL_NOT_FOUND", "分组不存在或已下线", 404); int changed = jdbc.update("UPDATE platform_api_keys SET model_ids = CAST(? AS jsonb) WHERE id = ? AND user_id = ? AND status = 'active'", writeJson(uniqueIds), UUID.fromString(keyId), user.id()); if (changed == 0) throw new ApiException("KEY_NOT_FOUND", "Key 不存在、已停用或无权修改", 404); return Map.of("apiKey", findKey(keyId)); @@ -185,13 +305,16 @@ public class CatalogService { result.put("tasks", Map.of("queued", 0, "running", 0, "succeeded", 0, "failed", 0)); result.put("series", List.of()); result.put("ledger", List.of()); + List balances=jdbc.queryForList("SELECT balance FROM user_wallets WHERE user_id=?",java.math.BigDecimal.class,user.id()); + result.put("availableCredit",balances.isEmpty()?java.math.BigDecimal.ZERO:balances.getFirst()); + result.put("ledger",jdbc.query("SELECT id, reason, amount, created_at FROM wallet_entries WHERE user_id=? ORDER BY created_at DESC LIMIT 100", (rs,n)->Map.of("id",rs.getString("id"),"title",rs.getString("reason"),"amount",rs.getBigDecimal("amount"),"createdAt",rs.getObject("created_at",OffsetDateTime.class)),user.id())); return result; } public Map authenticateKey(String plaintext) { if (plaintext == null || plaintext.isBlank()) return null; try { - return jdbc.queryForObject("SELECT * FROM platform_api_keys WHERE key_hash = ? AND status = 'active'", this::mapApiKey, sha256(plaintext.trim())); + return jdbc.queryForObject("SELECT k.* FROM platform_api_keys k JOIN users u ON u.id=k.user_id WHERE k.key_hash = ? AND k.status = 'active' AND u.status='active'", this::mapApiKey, sha256(plaintext.trim())); } catch (EmptyResultDataAccessException exception) { return null; } @@ -237,7 +360,7 @@ public class CatalogService { } private Map findActiveModel(String id) { - try { return jdbc.queryForObject("SELECT * FROM model_catalog WHERE id = ? AND status = 'active'", this::mapModel, id); } + try { return jdbc.queryForObject("SELECT m.* FROM model_catalog m JOIN model_providers p ON p.id=m.provider_id JOIN model_definitions d ON d.id=m.logical_model_id WHERE m.id = ? AND m.status = 'active' AND p.status='active' AND d.status='active'", this::mapModel, id); } catch (EmptyResultDataAccessException exception) { return null; } } @@ -274,6 +397,7 @@ public class CatalogService { private Map mapModel(ResultSet resultSet, int rowNumber) throws SQLException { Map model = new LinkedHashMap<>(); model.put("id", resultSet.getString("id")); + model.put("logicalModelId", resultSet.getString("logical_model_id")); model.put("providerId", resultSet.getString("provider_id")); putIfNotNull(model, "modelKey", resultSet.getString("model_key")); putIfNotNull(model, "sourceLabel", resultSet.getString("source_label")); diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/wallet/WalletController.java b/control-plane-java/src/main/java/com/moyi/controlplane/wallet/WalletController.java new file mode 100644 index 0000000..059a651 --- /dev/null +++ b/control-plane-java/src/main/java/com/moyi/controlplane/wallet/WalletController.java @@ -0,0 +1,23 @@ +package com.moyi.controlplane.wallet; + +import com.moyi.controlplane.auth.AuthController; +import jakarta.servlet.http.HttpServletRequest; +import java.util.Map; +import java.util.UUID; +import org.springframework.web.bind.annotation.*; + +@RestController +@RequestMapping("/api/admin") +public class WalletController { + private final WalletService wallet; + public WalletController(WalletService wallet) { this.wallet=wallet; } + public record GrantRequest(UUID requestId, String amount, String reason) {} + @GetMapping("/wallets") + public Map balances(HttpServletRequest request) { return Map.of("wallets",wallet.balances(AuthController.sessionToken(request))); } + @GetMapping("/users/{id}/wallet") + public Map entries(@PathVariable UUID id,HttpServletRequest request) { return Map.of("entries",wallet.entries(AuthController.sessionToken(request),id)); } + @PostMapping("/users/{id}/wallet/grants") + public Map grant(@PathVariable UUID id,@RequestBody GrantRequest input,HttpServletRequest request) { + return wallet.grant(AuthController.sessionToken(request),id,input.requestId(),input.amount(),input.reason(),AuthController.meta(request)); + } +} diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/wallet/WalletService.java b/control-plane-java/src/main/java/com/moyi/controlplane/wallet/WalletService.java new file mode 100644 index 0000000..d30c2c3 --- /dev/null +++ b/control-plane-java/src/main/java/com/moyi/controlplane/wallet/WalletService.java @@ -0,0 +1,60 @@ +package com.moyi.controlplane.wallet; + +import com.moyi.controlplane.auth.AuthService; +import com.moyi.controlplane.common.ApiException; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +public class WalletService { + private final JdbcTemplate jdbc; + private final AuthService auth; + + public WalletService(JdbcTemplate jdbc, AuthService auth) { this.jdbc=jdbc; this.auth=auth; } + + public List> balances(String token) { + auth.requireAdmin(token); + return jdbc.queryForList("SELECT u.id AS \"userId\", COALESCE(w.balance,0) AS balance FROM users u LEFT JOIN user_wallets w ON w.user_id=u.id"); + } + + public List> entries(String token, UUID userId) { + auth.requireAdmin(token); + return jdbc.queryForList("SELECT e.id, e.amount, e.balance_after AS \"balanceAfter\", e.currency, e.reason, e.created_at AS \"createdAt\", u.display_name AS actor FROM wallet_entries e JOIN users u ON u.id=e.actor_user_id WHERE e.user_id=? ORDER BY e.created_at DESC LIMIT 100",userId); + } + + @Transactional + public Map grant(String token, UUID userId, UUID requestId, String amountInput, String reasonInput, AuthService.RequestMeta meta) { + var actor=auth.requireAdmin(token); + if(requestId==null) throw new ApiException("INVALID_REQUEST_ID","请提供发放请求编号"); + BigDecimal amount; + try { + amount=new BigDecimal(amountInput).setScale(2,RoundingMode.UNNECESSARY); + if(amount.signum()<=0 || amount.compareTo(new BigDecimal("1000000"))>0) throw new NumberFormatException(); + } catch(Exception exception) { throw new ApiException("INVALID_AMOUNT","金额需大于 0,最多两位小数,单次不超过 100 万元"); } + String reason=reasonInput==null?"":reasonInput.trim(); + if(reason.isBlank() || reason.length()>500) throw new ApiException("INVALID_REASON","请填写发放原因(最多 500 字符)"); + if(jdbc.queryForObject("SELECT count(*) FROM users WHERE id=? AND status='active'",Integer.class,userId)==0) throw new ApiException("USER_NOT_FOUND","用户不存在或已停用",404); + // Lock the idempotency key before the wallet so concurrent retries cannot grant twice. + jdbc.queryForList("SELECT pg_advisory_xact_lock(hashtextextended(?, 0))",requestId.toString()); + List> existing=jdbc.queryForList("SELECT * FROM wallet_entries WHERE request_id=?",requestId); + if(!existing.isEmpty()) { + var entry=existing.getFirst(); + if(!userId.equals(entry.get("user_id")) || !actor.id().equals(entry.get("actor_user_id")) || amount.compareTo((BigDecimal)entry.get("amount"))!=0 || !reason.equals(entry.get("reason"))) throw new ApiException("REQUEST_CONFLICT","请求编号已被另一笔发放使用",409); + return Map.of("id",entry.get("id"),"balance",entry.get("balance_after"),"currency","CNY","replayed",true); + } + jdbc.update("INSERT INTO user_wallets(user_id) VALUES (?) ON CONFLICT DO NOTHING",userId); + BigDecimal balance=jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=? FOR UPDATE",BigDecimal.class,userId); + BigDecimal next=balance.add(amount); + UUID id=UUID.randomUUID(); + jdbc.update("UPDATE user_wallets SET balance=?, updated_at=now() WHERE user_id=?",next,userId); + jdbc.update("INSERT INTO wallet_entries(id,user_id,actor_user_id,request_id,amount,balance_after,reason) VALUES (?,?,?,?,?,?,?)",id,userId,actor.id(),requestId,amount,next,reason); + auth.audit("wallet.credit_granted",actor.id(),meta,Map.of("userId",userId,"entryId",id,"amount",amount,"currency","CNY","reason",reason)); + return Map.of("id",id,"balance",next,"currency","CNY","replayed",false); + } +} diff --git a/control-plane-java/src/main/resources/db/migration/V10__model_definitions_wallets_verification.sql b/control-plane-java/src/main/resources/db/migration/V10__model_definitions_wallets_verification.sql new file mode 100644 index 0000000..a3bae09 --- /dev/null +++ b/control-plane-java/src/main/resources/db/migration/V10__model_definitions_wallets_verification.sql @@ -0,0 +1,58 @@ +CREATE TABLE model_definitions ( + id varchar(64) PRIMARY KEY, + model_key varchar(160), + public_name varchar(160) NOT NULL, + model_type varchar(24) NOT NULL, + call_mode varchar(16) NOT NULL, + description text NOT NULL DEFAULT '', + input_types jsonb NOT NULL DEFAULT '[]', + output_types jsonb NOT NULL DEFAULT '[]', + status varchar(16) NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'disabled')), + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now() +); + +-- Keep existing route IDs and key grants intact. Do not guess which legacy names are identical models. +INSERT INTO model_definitions (id, model_key, public_name, model_type, call_mode, description, input_types, output_types, status) +SELECT id, model_key, public_name, model_type, call_mode, description, input_types, output_types, status FROM model_catalog; +ALTER TABLE model_catalog ADD COLUMN logical_model_id varchar(64) REFERENCES model_definitions(id); +UPDATE model_catalog SET logical_model_id = id; +ALTER TABLE model_catalog ALTER COLUMN logical_model_id SET NOT NULL; +UPDATE model_catalog SET source_label = '默认分组' WHERE source_label IS NULL OR trim(source_label) = ''; +CREATE INDEX model_catalog_logical_idx ON model_catalog(logical_model_id); +CREATE UNIQUE INDEX model_catalog_group_name_idx ON model_catalog(logical_model_id, source_label); + +CREATE TABLE user_wallets ( + user_id uuid PRIMARY KEY REFERENCES users(id), + balance numeric(20,8) NOT NULL DEFAULT 0 CHECK (balance >= 0), + updated_at timestamptz NOT NULL DEFAULT now() +); +CREATE TABLE wallet_entries ( + id uuid PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id), + actor_user_id uuid NOT NULL REFERENCES users(id), + request_id uuid NOT NULL UNIQUE, + amount numeric(20,8) NOT NULL CHECK (amount > 0), + balance_after numeric(20,8) NOT NULL, + currency varchar(3) NOT NULL DEFAULT 'CNY' CHECK (currency = 'CNY'), + reason varchar(500) NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); +CREATE INDEX wallet_entries_user_idx ON wallet_entries(user_id, created_at DESC); + +CREATE TABLE registration_codes ( + account varchar(254) PRIMARY KEY, + code_hash char(64) NOT NULL, + expires_at timestamptz NOT NULL, + attempts integer NOT NULL DEFAULT 0, + consumed boolean NOT NULL DEFAULT false, + created_at timestamptz NOT NULL DEFAULT now() +); +CREATE TABLE verification_send_events ( + id uuid PRIMARY KEY, + account varchar(254) NOT NULL, + ip_address varchar(128) NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); +CREATE INDEX verification_send_account_idx ON verification_send_events(account, created_at); +CREATE INDEX verification_send_ip_idx ON verification_send_events(ip_address, created_at); diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/PlatformAdminPostgresTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/PlatformAdminPostgresTest.java new file mode 100644 index 0000000..a4076a4 --- /dev/null +++ b/control-plane-java/src/test/java/com/moyi/controlplane/PlatformAdminPostgresTest.java @@ -0,0 +1,202 @@ +package com.moyi.controlplane; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.moyi.controlplane.auth.*; +import com.moyi.controlplane.catalog.CatalogService; +import com.moyi.controlplane.common.ApiException; +import com.moyi.controlplane.common.ApiExceptionHandler; +import com.moyi.controlplane.security.SecretCipher; +import com.moyi.controlplane.wallet.WalletService; +import jakarta.servlet.http.Cookie; +import java.math.BigDecimal; +import java.util.*; +import java.util.concurrent.*; +import javax.sql.DataSource; +import org.flywaydb.core.Flyway; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; +import org.springframework.context.annotation.*; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.datasource.*; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.transaction.annotation.EnableTransactionManagement; +import static org.junit.jupiter.api.Assertions.*; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; + +@EnabledIfEnvironmentVariable(named="MOYI_AUTH_TEST_JDBC_URL", matches="jdbc:postgresql://127\\.0\\.0\\.1:[0-9]+/.+") +class PlatformAdminPostgresTest { + @Configuration @EnableTransactionManagement(proxyTargetClass=true) + static class Transactions {} + static class TestSender implements VerificationSender { + final Map codes = new ConcurrentHashMap<>(); + boolean enabled = true; + boolean fail = false; + public boolean available(String channel) { return enabled; } + public void send(String channel, String account, String code) { + if (fail) throw new ApiException("VERIFICATION_SEND_FAILED", "Test sender unavailable", 502); + codes.put(account, code); + } + } + private final ObjectMapper json = new ObjectMapper().findAndRegisterModules(); + private final AuthService.RequestMeta meta = new AuthService.RequestMeta("127.0.0.1", "isolated-test"); + private DriverManagerDataSource base; + private AnnotationConfigApplicationContext context; + private JdbcTemplate jdbc; + private String schema, ownerToken, memberToken; + private UUID memberId; + private AuthService auth; + private CatalogService catalog; + private WalletService wallet; + private VerificationService verification; + private TestSender sender; + + @BeforeEach void setup() throws Exception { + String url = System.getenv("MOYI_AUTH_TEST_JDBC_URL"); + schema = "platform_test_" + UUID.randomUUID().toString().replace("-", ""); + base = new DriverManagerDataSource(url, "moyi_role_test", ""); + var source = new DriverManagerDataSource(url + "?currentSchema=" + schema, "moyi_role_test", ""); + jdbc = new JdbcTemplate(source); + Flyway.configure().dataSource(base).schemas(schema).defaultSchema(schema).target("9").load().migrate(); + var legacyIds = jdbc.queryForList("SELECT id FROM model_catalog ORDER BY id", String.class); + UUID legacyUser = UUID.randomUUID(), legacyKey = UUID.randomUUID(); + String legacyGrants = json.writeValueAsString(List.of(legacyIds.getFirst())); + jdbc.update("INSERT INTO users(id,account,account_kind,password_hash,display_name) VALUES (?,'legacy_member','username','not-a-login-hash','Legacy Member')", legacyUser); + jdbc.update("INSERT INTO platform_api_keys(id,user_id,name,key_prefix,key_hash,model_ids) VALUES (?,?,'Legacy Key','test-prefix',?,?::jsonb)", legacyKey, legacyUser, "a".repeat(64), legacyGrants); + Flyway.configure().dataSource(base).schemas(schema).defaultSchema(schema).load().migrate(); + assertEquals(legacyIds, jdbc.queryForList("SELECT id FROM model_catalog ORDER BY id", String.class)); + assertEquals(legacyIds, jdbc.queryForList("SELECT logical_model_id FROM model_catalog ORDER BY id", String.class)); + assertEquals(json.readTree(legacyGrants), json.readTree(jdbc.queryForObject("SELECT model_ids::text FROM platform_api_keys WHERE id=?", String.class, legacyKey))); + context = new AnnotationConfigApplicationContext(); + sender = new TestSender(); + context.register(Transactions.class); + context.registerBean(DataSource.class, () -> source); + context.registerBean(DataSourceTransactionManager.class, () -> new DataSourceTransactionManager(source)); + context.registerBean(AuthService.class, () -> new AuthService(jdbc, new PasswordHasher("test-pepper"), json, 168)); + context.registerBean(CatalogService.class, () -> new CatalogService(jdbc, json, new SecretCipher("test-encryption"))); + context.registerBean(WalletService.class, () -> new WalletService(jdbc, context.getBean(AuthService.class))); + context.registerBean(VerificationService.class, () -> new VerificationService(jdbc, sender, "test-pepper")); + context.refresh(); + auth = context.getBean(AuthService.class); + catalog = context.getBean(CatalogService.class); + wallet = context.getBean(WalletService.class); + verification = context.getBean(VerificationService.class); + auth.ensureAdmin("test_owner", "local-password", "Test Owner"); + ownerToken = auth.login("test_owner", "local-password", meta).token(); + memberId = auth.createUser(ownerToken, "test_member", "local-password", "Test Member", meta).id(); + memberToken = auth.login("test_member", "local-password", meta).token(); + } + @AfterEach void cleanup() { + if (context != null) context.close(); + // Only the random schema created by this isolated test is removed. + if (base != null && schema != null) new JdbcTemplate(base).execute("DROP SCHEMA IF EXISTS " + schema + " CASCADE"); + } + @Test void modelGroupsKeepExactKeyGrantsAndEditableChannels() { + var channel = catalog.createProvider(Map.of("code","test-relay","name","Relay","protocol","openai-compatible","sourceType","relay","baseUrl","https://example.test/v1","credentialType","api-key","credentialSecret","only-a-test-secret"), ownerToken, auth); + String channelId = channel.get("id").toString(); + String cipher = jdbc.queryForObject("SELECT credential_ciphertext FROM model_providers WHERE id=?", String.class, channelId); + var model = catalog.saveDefinition(null,Map.of("publicName","Test Model","type","text","mode","sync"),ownerToken,auth); + String modelId = model.get("id").toString(); + var first = catalog.createModel(Map.of("logicalModelId",modelId,"providerId",channelId,"sourceLabel","Primary","upstreamModel","upstream-a"),ownerToken,auth); + String firstId = first.get("id").toString(); + var second = catalog.createModel(Map.of("logicalModelId",modelId,"providerId",channelId,"sourceLabel","Backup","upstreamModel","upstream-b"),ownerToken,auth); + String secondId = second.get("id").toString(); + var keyResult = catalog.createKey(memberToken,Map.of("modelIds",List.of(firstId)),auth); + String plaintext = keyResult.get("key").toString(); + var key = catalog.authenticateKey(plaintext); + String keyId = key.get("id").toString(); + assertTrue(catalog.keyCanInvoke(key,firstId)); + assertFalse(catalog.keyCanInvoke(key,secondId)); + assertFalse(catalog.keyCanInvoke(key,modelId)); + assertThrows(ApiException.class, () -> catalog.updateKeyModels(ownerToken,keyId,List.of(secondId),auth)); + var edited = catalog.updateProvider(channelId,Map.of("name","Relay Updated","baseUrl","https://example.test/v2","credentialSecret",""),ownerToken,auth); + assertEquals("Relay Updated",edited.get("name")); + assertFalse(edited.containsKey("credentialSecret")); + assertEquals(cipher,jdbc.queryForObject("SELECT credential_ciphertext FROM model_providers WHERE id=?",String.class,channelId)); + catalog.saveDefinition(modelId,Map.of("publicName","Renamed"),ownerToken,auth); + assertEquals("Renamed",catalog.activeModel(firstId).get("publicName")); + catalog.updateModel(firstId,Map.of("sourceLabel","Edited Group","upstreamModel","upstream-c","maxConcurrency",2),ownerToken,auth); + assertEquals("upstream-c",catalog.activeModel(firstId).get("upstreamModel")); + assertTrue(catalog.keyCanInvoke(catalog.authenticateKey(plaintext),firstId)); + catalog.updateProvider(channelId,Map.of("status","disabled"),ownerToken,auth); + assertNull(catalog.activeModel(firstId)); + assertTrue(catalog.listModels(false).stream().noneMatch(row -> row.get("id").equals(firstId))); + catalog.updateKeyModels(memberToken,keyId,List.of(firstId),auth); + assertThrows(ApiException.class, () -> catalog.updateKeyModels(memberToken,keyId,List.of(firstId,secondId),auth)); + catalog.updateProvider(channelId,Map.of("status","active"),ownerToken,auth); + catalog.saveDefinition(modelId,Map.of("status","disabled"),ownerToken,auth); + assertNull(catalog.activeModel(firstId)); + catalog.saveDefinition(modelId,Map.of("status","active"),ownerToken,auth); + catalog.updateModel(firstId,Map.of("status","disabled"),ownerToken,auth); + assertNull(catalog.activeModel(firstId)); + catalog.updateKeyModels(memberToken,keyId,List.of(),auth); + assertFalse(catalog.keyCanInvoke(catalog.authenticateKey(plaintext),firstId)); + jdbc.update("UPDATE users SET status='disabled' WHERE id=?",memberId); + assertNull(catalog.authenticateKey(plaintext)); + assertThrows(ApiException.class, () -> catalog.updateProvider(channelId,Map.of("name","bad"),memberToken,auth)); + } + + @Test void grantsAreExactAuditedIdempotentAndConcurrent() throws Exception { + assertThrows(ApiException.class, () -> wallet.grant(memberToken,memberId,UUID.randomUUID(),"1","unauthorized",meta)); + for (String invalid : List.of("0","-1","1.001","NaN","1000000.01")) assertThrows(ApiException.class, () -> wallet.grant(ownerToken,memberId,UUID.randomUUID(),invalid,"invalid",meta)); + UUID request = UUID.randomUUID(); + try (var pool = Executors.newFixedThreadPool(4)) { + var one = pool.submit(() -> wallet.grant(ownerToken,memberId,request,"12.30","test grant",meta)); + var retry = pool.submit(() -> wallet.grant(ownerToken,memberId,request,"12.30","test grant",meta)); + assertEquals(one.get(10,TimeUnit.SECONDS).get("id"),retry.get(10,TimeUnit.SECONDS).get("id")); + var two = pool.submit(() -> wallet.grant(ownerToken,memberId,UUID.randomUUID(),"0.10","second",meta)); + var three = pool.submit(() -> wallet.grant(ownerToken,memberId,UUID.randomUUID(),"0.20","third",meta)); + two.get(10,TimeUnit.SECONDS); three.get(10,TimeUnit.SECONDS); + } + assertThrows(ApiException.class, () -> wallet.grant(ownerToken,memberId,request,"99","test grant",meta)); + assertEquals(0,new BigDecimal("12.60").compareTo(jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId))); + assertEquals(3,wallet.entries(ownerToken,memberId).size()); + assertEquals(3,jdbc.queryForObject("SELECT count(*) FROM auth_audit_log WHERE event_type='wallet.credit_granted'",Integer.class)); + assertEquals(0,new BigDecimal("12.60").compareTo((BigDecimal)catalog.overview(memberToken,auth).get("availableCredit"))); + } + + @Test void directCreationCannotEscalateAndOtpIsRequiredOnBothChannels() throws Exception { + MockMvc http = MockMvcBuilders.standaloneSetup(new AuthController(auth,verification,168,false)).setControllerAdvice(new ApiExceptionHandler()).build(); + http.perform(post("/api/admin/users").cookie(new Cookie("moyi_session",ownerToken)).contentType("application/json").content("{\"account\":\"created_user\",\"password\":\"test-password\",\"role\":\"super_admin\"}")) + .andExpect(status().isCreated()).andExpect(jsonPath("$.user.role").value("user")).andExpect(jsonPath("$.user.password").doesNotExist()); + http.perform(post("/api/admin/users").cookie(new Cookie("moyi_session",memberToken)).contentType("application/json").content("{\"account\":\"bad_user\",\"password\":\"test-password\"}")) + .andExpect(status().isForbidden()); + String invite = auth.createInvitation(ownerToken,"otp test",10,null,meta).get("code").toString(); + for (String account : List.of("otp@example.test","13800000000")) { + var input = new LinkedHashMap(Map.of("account",account,"password","test-password","invitationCode",invite)); + http.perform(post("/api/auth/register").contentType("application/json").content(json.writeValueAsBytes(input))).andExpect(status().isBadRequest()); + http.perform(post("/api/auth/verification").contentType("application/json").content(json.writeValueAsBytes(input))) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").doesNotExist()).andExpect(jsonPath("$.sent").value(true)); + String code = sender.codes.get(account); + assertNotEquals(code,jdbc.queryForObject("SELECT code_hash FROM registration_codes WHERE account=?",String.class,account)); + input.put("verificationCode",code); + http.perform(post("/api/auth/register").contentType("application/json").content(json.writeValueAsBytes(input))) + .andExpect(status().isCreated()).andExpect(jsonPath("$.user.role").value("user")); + assertThrows(ApiException.class, () -> verification.consume(account,code)); + } + } + + @Test void otpLimitsExpiryAndFailedSendsPersistAcrossTransactions() { + String invite = auth.createInvitation(ownerToken,"otp limits",20,null,meta).get("code").toString(); + String account="limits@example.test"; + assertThrows(ApiException.class, () -> verification.send(account,"bad-invite","127.0.0.1")); + verification.send(account,invite,"127.0.0.1"); + assertThrows(ApiException.class, () -> verification.send(account,invite,"127.0.0.1")); + String correct=sender.codes.get(account); + String wrong=correct.equals("000000")?"111111":"000000"; + for(int i=0;i<5;i++) assertThrows(ApiException.class, () -> verification.consume(account,wrong)); + assertEquals(5,jdbc.queryForObject("SELECT attempts FROM registration_codes WHERE account=?",Integer.class,account)); + assertThrows(ApiException.class, () -> verification.consume(account,correct)); + verification.send("expired@example.test",invite,"127.0.0.1"); + jdbc.update("UPDATE registration_codes SET expires_at=now()-interval '1 second' WHERE account='expired@example.test'"); + assertThrows(ApiException.class, () -> verification.consume("expired@example.test",sender.codes.get("expired@example.test"))); + sender.fail=true; + assertThrows(ApiException.class, () -> verification.send("failed@example.test",invite,"127.0.0.1")); + assertTrue(jdbc.queryForObject("SELECT consumed FROM registration_codes WHERE account='failed@example.test'",Boolean.class)); + assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account='failed@example.test'",Integer.class)); + sender.enabled=false; + assertFalse(verification.capabilities().containsValue(true)); + assertThrows(ApiException.class, () -> verification.send("unavailable@example.test",invite,"127.0.0.1")); + } +} diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/auth/AuthPostgresTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/auth/AuthPostgresTest.java index 05cf889..a7fa03e 100644 --- a/control-plane-java/src/test/java/com/moyi/controlplane/auth/AuthPostgresTest.java +++ b/control-plane-java/src/test/java/com/moyi/controlplane/auth/AuthPostgresTest.java @@ -64,7 +64,7 @@ class AuthPostgresTest { assertThrows(DataIntegrityViolationException.class, () -> jdbc.update("UPDATE users SET role = 'super_admin' WHERE id = ?", operatorId)); assertThrows(IllegalStateException.class, () -> auth.ensureAdmin("operator", "test-password", "Other")); - MockMvc http = MockMvcBuilders.standaloneSetup(new AuthController(auth, 168, true)) + MockMvc http = MockMvcBuilders.standaloneSetup(new AuthController(auth, org.mockito.Mockito.mock(VerificationService.class), 168, true)) .setControllerAdvice(new ApiExceptionHandler()).build(); var ownerCookie = login(http, "adimin", "super_admin"); var operatorCookie = login(http, "operator", "admin"); diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/auth/PasswordHasherInteropTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/auth/PasswordHasherInteropTest.java new file mode 100644 index 0000000..e5b3f65 --- /dev/null +++ b/control-plane-java/src/test/java/com/moyi/controlplane/auth/PasswordHasherInteropTest.java @@ -0,0 +1,18 @@ +package com.moyi.controlplane.auth; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class PasswordHasherInteropTest { + @Test + void acceptsMaintenanceScriptPbkdf2HashesIncludingUnicode() { + PasswordHasher hasher = new PasswordHasher("local-test-pepper"); + // Python hashlib fixtures with salt bytes 0..15; no real credentials. + String ascii = "pbkdf2$210000$AAECAwQFBgcICQoLDA0ODw$_ZW4zVJDiheXQ51WuP_SSr_f8xjYJXBHvjkzLlPtFHo"; + String unicode = "pbkdf2$210000$AAECAwQFBgcICQoLDA0ODw$qZ4RLM7vU3k0rCJtetdh8uSbnAkWbxFYR7sD4GYRmb8"; + assertTrue(hasher.matches("Qa-Test42!", ascii)); + assertTrue(hasher.matches("\u6d4b\u8bd5A1!", unicode)); + assertFalse(hasher.matches("wrong-password", ascii)); + assertFalse(new PasswordHasher("wrong-pepper").matches("Qa-Test42!", ascii)); + } +} diff --git a/docs/11-server-test-deployment.md b/docs/11-server-test-deployment.md index e9d94d0..880371c 100644 --- a/docs/11-server-test-deployment.md +++ b/docs/11-server-test-deployment.md @@ -275,6 +275,29 @@ sudo python3 deploy.py reload-tls --mode https V9 迁移扩展角色约束、增加超级管理员唯一索引,应用启动时升级指定账号。旧程序只识别 `admin`,**V9 启用后不能直接切回旧版 JAR**;需要兼容新版角色的修复版本,或由维护人员将升级前备份恢复到独立测试库后验证回退。不要手工修改 Flyway 历史或删除唯一索引。 +### 修改已存在的超级管理员账号和密码 + +`ADMIN_ACCOUNT` / `ADMIN_PASSWORD` 只用于初始化和启动校验,修改环境变量本身不会更新已有密码。不要先修改账号环境变量再重启,避免触发唯一超级管理员保护。 + +单机 Docker Compose 部署可使用 `infra/moyi/admin_credentials.py`。它依赖服务器 Python 3.11+、Docker Compose 和 PostgreSQL 客户端;通过运行版本的 `deploy.py` 解析配置,不在命令行或日志中输出密码。将该脚本放在发布目录外,例如 `/opt/moyi/tools/admin_credentials.py`,避免改动已有发布包的校验文件。 + +```bash +sudo python3 /opt/moyi/tools/admin_credentials.py --deployment-dir /opt/moyi/releases/<当前版本>/infra/moyi --account MLKJAdmin --database moyi_control --mode https +sudo python3 /opt/moyi/tools/admin_credentials.py --deployment-dir /opt/moyi/releases/<当前版本>/infra/moyi --account MLKJAdmin --database moyi_control --mode https --apply +``` + +第一条只检查;第二条须在交互式 SSH 中单独执行,隐藏输入两次新密码。没有密码最低长度要求,拒绝空白、控制字符、开发默认密码和部署配置占位符。脚本会: + +1. 核对唯一活跃超级管理员、目标库、账号占用、运行容器的发布目录与数据库/加密配置。 +2. 保存修改前后的环境配置,调用 Compose 验证只有管理员账号和密码发生变化。 +3. 短暂停止后端,将当前专用数据库导出到 `/opt/moyi/backups/owner-reset-*`,保留环境密钥;备份和配置仅 root 可读。 +4. 在同一数据库事务中修改原账号及 PBKDF2 哈希、撤销该账号旧会话、记录审计,不新建用户、不改变用户 ID、角色、显示名称或业务关联。 +5. 原子替换环境文件,使用现有镜像重建后端,重载容器 Nginx 并验证新超级管理员登录。账号匹配不区分大小写,数据库内使用小写规范形式。 + +执行前应暂停平台测试,维护期间不要并行修改 `.env.cloud`、发布或启动其他后端实例。密码只在服务器输入,不写进源码、发布包、Shell 历史。工具不会重新构建镜像或修改数据库迁移文件。 + +若数据库修改前失败,工具尝试启动原后端;若数据库事务已尝试提交后失败,不自动还原数据库或旧配置,以免状态不一致。保留工具输出的私有恢复目录,使用相同账号和密码重跑工具完成配置同步及验收。不要盲目恢复整个共享 RDS 实例、切回旧版程序或旧环境配置。成功后将恢复目录保存在受控位置,不提交 Git。 + ## 8. 还需提供的信息 - RDS 内网地址、端口、新库和账号名、所属 VPC;Tair 内网地址、端口、账号、TLS 状态及 VPC。 diff --git a/docs/13-model-groups-registration-credit.md b/docs/13-model-groups-registration-credit.md new file mode 100644 index 0000000..41e7970 --- /dev/null +++ b/docs/13-model-groups-registration-credit.md @@ -0,0 +1,76 @@ +# 模型分组、注册验证与人民币额度 + +## 本次变更 + +- 渠道:独立维护名称、Code、来源类型、协议、Base URL、凭据和启停状态。编辑时凭据留空保留原值;选择“不使用凭据”才清除。 +- 模型:独立维护名称、标识、能力类型和调用模式。 +- 分组:在模型下添加,自定义名称、选择渠道、填写上游模型 ID、报价、并发上限;均可再次编辑。 +- Key:先选模型,再勾选该模型的分组,可继续切换模型配置其他分组。授权只包含已保存的分组,不自动扩展到未来新增分组。清空授权后 Key 不能调用模型。 +- 在线调试:模型和分组直接下拉选择;无需返回模型广场。 +- 用户与额度:管理员可直接开通普通账号、创建邀请、发放人民币金额并查看流水;只有超级管理员能升降管理员角色。 + +`/api/models` 保留 `models`(分组/调用路由列表),新增 `logicalModels`(模型定义)。调用仍使用分组的 `id` 作为 `/v1/chat/completions` 的 `model` 值;`modelKey` 是可编辑的展示标识,不是自动路由或授权通配符。 + +## 旧数据升级 + +Flyway V10 自动将每条旧目录项转换为一个模型和一个既有分组;保留旧调用 ID、Key 权限及凭据。为避免错误合并,不按名称自动合并旧模型。需要合并时,在“编辑分组”中更改所属模型,再停用已无分组的旧模型即可。 + +停用渠道、模型或分组后,对应调用立即不可用;旧 Key 的既有授权仍保留,重新启用后恢复。不能给 Key 新增已停用分组的权限。同一模型内分组名称不能重复。 + +升级前备份 RDS 的专用数据库、`.env.cloud`、认证 pepper、凭据加密密钥及证书。不要连接或修改其他业务库。V10 上线后不要直接回滚到会写入旧目录结构的旧程序;需要回滚时使用升级前备份和对应旧版本。 + +旧版 `20260917-202503-f5ba6cb2` 尚无验证码实现和 SMTP/SMS 环境变量映射;只改 `.env.cloud` 或重启旧容器不会启用验证码。必须升级后端、前端及 Compose。复制旧配置到新发布目录,保留所有密钥和新填的 SMTP/SMS 参数,只更新镜像版本与运行时 Dockerfile 设置。 + +新包提供 `infra/moyi/backup_database.py`,在运行新版本 `up` 之前执行: + +```bash +# 在新发布目录的 infra/moyi 下运行;指向当前仍在运行的旧版本。 +python3 backup_database.py --deployment-dir /opt/moyi/releases/20260917-202503-f5ba6cb2/infra/moyi --mode https +``` + +工具核对运行容器、数据库及加密配置,只导出 `moyi_control`;同时保存旧 `.env.cloud`(含 SMTP/SMS)和证书,在 `/opt/moyi/backups/pre-upgrade-*` 创建私有备份。导出后读取整个归档并生成校验清单,成功才输出 `BACKUP_OK`。此检查不等同于向独立数据库实际恢复的演练。备份期间停止人工测试并保持配置不变;命令失败时不要继续升级。备份是一个一致性快照,备份后的新写入不包含在其中。 + +升级后运行 `python3 deploy.py smoke --mode https --login` 和 `curl --fail --silent --show-error https://moyi.soulofmodel.com/api/auth/verification`。后者只检查发送通道是否配置,不发送验证码;`email: true` 不是投递成功的证明。再通过注册页面用有效邀请码和自己控制的邮箱/手机号完成真实收发与注册验收。 + +## 邮箱和短信配置 + +注册现在同时要求有效邀请码和 6 位验证码。邮箱、手机号二选一注册,不要求每个人同时验证两种联系方式。手机目前支持中国大陆号码(可带 `+86`)。登录仍使用账号和密码。管理员直接开户不需要验证码,不会自动取得管理员权限。 + +未配置的发送通道显示“暂不可用”,不会生成假成功;管理员仍能直接开户。密码找回不在本次实现范围内。 + +在服务器当前发布目录的 `infra/moyi/.env.cloud` 中填写以下变量,不提交到 Git,不将完整凭据发到聊天中。包含 `$`、`#` 等字符的值用单引号。 + +| 邮箱变量 | 内容 | +| --- | --- | +| `MOYI_SMTP_HOST` | 邮箱服务商的 SMTP 主机 | +| `MOYI_SMTP_PORT` | 通常为 `465`(SSL)或 `587`(STARTTLS),以服务商为准 | +| `MOYI_SMTP_FROM` | 已验证的发件邮箱 | +| `MOYI_SMTP_USERNAME` | SMTP 登录账号 | +| `MOYI_SMTP_PASSWORD` | SMTP 密码或邮箱授权码 | +| `MOYI_SMTP_SSL` | 465 通常设为 `true`;587 通常为 `false` | +| `MOYI_SMTP_STARTTLS` | 587 通常设为 `true`;465 通常为 `false` | + +阿里云短信操作: + +1. 打开短信服务控制台,完成资质并申请中国大陆短信签名。 +2. 申请验证码模板,模板变量使用 `${code}`,有效期文案为 5 分钟;等待签名和模板审核通过。 +3. 建立专用于本项目短信发送的 RAM 凭据,按官方文档授予 `dysms:SendSms` 所需最小权限,不复用其他业务或主账号 AccessKey。 +4. 填入 `MOYI_SMS_ACCESS_KEY_ID`、`MOYI_SMS_ACCESS_KEY_SECRET`、`MOYI_SMS_SIGN_NAME`、`MOYI_SMS_TEMPLATE_CODE`。 +5. 在阿里云设置发送频率及费用预警,确认短信余额与服务器到短信服务的 HTTPS 出站连接。 +6. 使用部署脚本重建/重启新版本容器,让环境变量生效;不要只在页面刷新。用自己控制的邮箱和手机号各做一次真实验证码收发验收。 + +官方资料:[短信 API 接入](https://help.aliyun.com/zh/sms/getting-started/use-sms-api)。本地测试不调用真实发送服务,配置完成后仍需上述真实发送验收。 + +验证码 5 分钟有效,错误 5 次后失效,一次性使用。发送限制为同一账号 60 秒间隔、每账号每日 10 次、每来源 IP 每小时 30 次、全平台每日 1000 次;失败的发送请求也占用频率额度。哈希存储验证码,不写入日志或返回前端。发送记录保留最近 2 天。公司共享出口 IP 也共享来源 IP 额度。 + +云端 Nginx 覆盖客户端转发 IP,并清除外部 `Forwarded`,Java 后端不直接发布公网端口。自行新增代理时需维护这一信任边界,否则来源 IP 限制可能失效或合并。 + +## 人民币额度边界 + +发放金额以人民币元输入,最多两位小数、必须大于 0,单笔上限 100 万元。发放必须填写原因,记录操作者、时间、金额和发放后余额;使用事务、钱包行锁和请求编号去重。发放请求遇到网络不确定状态时,原弹窗重试沿用同一个编号,不会重复发放。 + +本次完成的是余额、发放、查询、流水与审计;不是充值支付或自动扣费。分组价格目前是报价元数据,不能把美元报价或每千/百万 token 单位直接用于人民币扣费。网关尚不根据余额拦截或结算;对外收费前仍必须实现明确币种和计费单位、预占额度、成功结算、失败退回及对账。优先级也尚未用于自动故障切换。 + +## 本地验证 + +`PlatformAdminPostgresTest` 仅接受 `127.0.0.1` 的 `MOYI_AUTH_TEST_JDBC_URL`,使用 `moyi_role_test` 测试角色与随机 schema;覆盖迁移、精确分组授权、编辑/停用、直接开户权限、额度并发去重,以及邮箱/手机验证码、锁定、过期、重复提交与发送失败。测试发送器不接入外部服务。 diff --git a/infra/moyi/.env.cloud.example b/infra/moyi/.env.cloud.example index bb3244a..45a6aab 100644 --- a/infra/moyi/.env.cloud.example +++ b/infra/moyi/.env.cloud.example @@ -46,6 +46,23 @@ GATEWAY_DEFAULT_MODEL_CONCURRENCY=4 TASK_MAX_QUEUED_PER_MODEL=100 MOYI_TASK_WORKER_INTERVAL_MS=1000 +# Registration requires a valid invitation AND an email/SMS verification code. +# Unconfigured channels fail closed; admins can still create user accounts. +# SMTP authorization password, not your mailbox login password where applicable. +MOYI_SMTP_HOST= +MOYI_SMTP_PORT=465 +MOYI_SMTP_FROM= +MOYI_SMTP_USERNAME= +MOYI_SMTP_PASSWORD= +MOYI_SMTP_SSL=true +MOYI_SMTP_STARTTLS=false +# Aliyun domestic SMS: approved signature + template with a ${code} variable. +# Use a dedicated least-privilege RAM credential for SendSms only. +MOYI_SMS_ACCESS_KEY_ID= +MOYI_SMS_ACCESS_KEY_SECRET= +MOYI_SMS_SIGN_NAME= +MOYI_SMS_TEMPLATE_CODE= + # OPTIONAL: use admin UI OR environment for one synchronous provider. # Environment credentials take precedence over admin UI credentials. DEEPSEEK_API_KEY= diff --git a/infra/moyi/admin_credentials.py b/infra/moyi/admin_credentials.py new file mode 100644 index 0000000..c50a95f --- /dev/null +++ b/infra/moyi/admin_credentials.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +"""Reset the existing owner of a single-instance MOYI cloud deployment.""" +import argparse +import base64 +import copy +import getpass +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import re +import secrets +import shutil +import subprocess +import sys +import tempfile +import urllib.parse + + +class MaintenanceError(Exception): + pass + + +def require(condition, message): + if not condition: + raise MaintenanceError(message) + + +def run(command, *, cwd=None, env=None, sql=None, timeout=240): + options = {"input": sql} if sql is not None else {"stdin": subprocess.DEVNULL} + result = subprocess.run(command, cwd=cwd, env=env, capture_output=True, + text=True, encoding="utf-8", timeout=timeout, **options) + # Database/Compose error messages can contain secrets or SQL; never echo them. + require(result.returncode == 0, Path(command[0]).name + " failed; output withheld to protect credentials.") + return result.stdout.strip() + + +def password_hash(password, pepper): + salt = secrets.token_bytes(16) + key = hashlib.pbkdf2_hmac("sha256", (password + pepper).encode("utf-8"), salt, 210000, 32) + encode = lambda value: base64.urlsafe_b64encode(value).decode("ascii").rstrip("=") + return "pbkdf2$210000$" + encode(salt) + "$" + encode(key) + + +def sql_literal(value): + # Hex also prevents dollar-quote delimiters from appearing inside a DO body. + return "convert_from(decode('" + str(value).encode("utf-8").hex() + "', 'hex'), 'UTF8')" + + +def updated_environment(original, account, password): + require(password.strip() and not any(ord(char) < 32 or ord(char) == 127 for char in password), + "Password must be nonblank and cannot contain control characters.") + require(password != "admin123", "The development default password is not allowed.") + # Append effective overrides, then ask Compose to validate them. Do not parse + # or rewrite arbitrary existing dotenv values, which may be multiline/quoted. + values = {"ADMIN_ACCOUNT": account, "ADMIN_PASSWORD": password} + return original.rstrip("\r\n") + "\n\n# Owner credentials set by admin_credentials.py\n" + "".join( + key + "=" + json.dumps(value, ensure_ascii=False).replace("$", "$$") + "\n" + for key, value in values.items()) + + +def validate_staged_config(before, after, account, password): + expected = copy.deepcopy(before) + expected["services"]["moyi-api"]["environment"].update( + ADMIN_ACCOUNT=account, ADMIN_PASSWORD=password) + require(after == expected, "Staged configuration differs unexpectedly. Check shell environment overrides; nothing was changed.") + + +def postgres_environment(api, expected_database): + url = str(api["SPRING_DATASOURCE_URL"]) + require(url.startswith("jdbc:postgresql://"), "PostgreSQL JDBC URL required.") + target = urllib.parse.urlsplit(url[5:]) + require(urllib.parse.unquote(target.path) == "/" + expected_database and target.hostname + and not target.username and not target.password, "Database target does not match --database.") + query = urllib.parse.parse_qs(target.query, keep_blank_values=True) + supported = {"sslmode": "PGSSLMODE", "sslrootcert": "PGSSLROOTCERT", "sslcert": "PGSSLCERT", "sslkey": "PGSSLKEY"} + require(all(key in supported and len(value) == 1 for key, value in query.items()), + "Unsupported JDBC parameters; review TLS settings before maintenance.") + env = {key: value for key, value in os.environ.items() if not key.startswith("PG")} + env.update(PGHOST=target.hostname, PGPORT=str(target.port or 5432), PGDATABASE=expected_database, + PGUSER=str(api["SPRING_DATASOURCE_USERNAME"]), PGPASSWORD=str(api["SPRING_DATASOURCE_PASSWORD"]), + PGCONNECT_TIMEOUT="10", PGAPPNAME="moyi-admin-maintenance", PGCLIENTENCODING="UTF8") + for key, value in query.items(): + env[supported[key]] = value[0] + return env + + +def query_database(psql, env, sql): + return run([psql, "-X", "--no-password", "-qAt", "-v", "ON_ERROR_STOP=1", "-f", "-"], env=env, sql=sql) + + +def read_owner(psql, env, configured_account, new_account): + rows = json.loads(query_database(psql, env, """ +SELECT COALESCE(json_agg(json_build_object('id', id, 'account', account, 'status', status)), '[]'::json) +FROM public.users WHERE role = 'super_admin'; +""")) + require(len(rows) == 1 and rows[0]["status"] == "active", "Expected exactly one active super administrator.") + normalized = re.sub(r"[\s-]", "", configured_account.strip().lower()) + # The second case permits retry after DB commit but before env installation. + require(rows[0]["account"] in (normalized, new_account.lower()), + "Existing owner differs from both configured and requested accounts; refusing to change it.") + occupied = query_database(psql, env, "SELECT count(*) FROM public.users WHERE account = " + + sql_literal(new_account.lower()) + " AND id <> " + sql_literal(rows[0]["id"]) + "::uuid;") + require(occupied == "0", "Requested account is already used by another user; nothing changed.") + return rows[0] + + +def reset_sql(database, owner, account, encoded): + database, user_id, previous, account, encoded = map(sql_literal, ( + database, owner["id"], owner["account"], account.lower(), encoded)) + return f""" +BEGIN; +SET LOCAL standard_conforming_strings = on; +SET LOCAL lock_timeout = '10s'; +SET LOCAL statement_timeout = '30s'; +LOCK TABLE public.users IN SHARE ROW EXCLUSIVE MODE; +DO $moyi_reset$ +BEGIN + IF current_database() <> {database} THEN + RAISE EXCEPTION 'Wrong database'; + END IF; + IF (SELECT count(*) FROM public.users WHERE role = 'super_admin') <> 1 + OR NOT EXISTS (SELECT 1 FROM public.users WHERE id = {user_id}::uuid + AND account = {previous} AND role = 'super_admin' AND status = 'active') THEN + RAISE EXCEPTION 'Owner changed; refusing reset'; + END IF; + IF EXISTS (SELECT 1 FROM public.users WHERE account = {account} AND id <> {user_id}::uuid) THEN + RAISE EXCEPTION 'Account already exists'; + END IF; + UPDATE public.users SET account = {account}, account_kind = 'username', + password_hash = {encoded}, updated_at = now() WHERE id = {user_id}::uuid; + UPDATE public.auth_sessions SET revoked_at = now() + WHERE user_id = {user_id}::uuid AND revoked_at IS NULL; + INSERT INTO public.auth_audit_log (actor_user_id, event_type, target_type, target_id, details) + VALUES ({user_id}::uuid, 'user.credentials_reset', 'user', {user_id}, + json_build_object('fromAccount', {previous}, 'account', {account}, 'method', 'server_cli')::jsonb); +END; +$moyi_reset$; +COMMIT; +SELECT 'OWNER_RESET_COMMITTED'; +""" + + +def write_private(path, data): + descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) + with os.fdopen(descriptor, "wb") as stream: + stream.write(data) + stream.flush() + os.fsync(stream.fileno()) + + +def install_environment(env_file, content): + temporary = env_file.with_name(".env.owner-" + secrets.token_hex(8)) + write_private(temporary, content) + os.replace(temporary, env_file) + if os.name != "nt": + descriptor = os.open(env_file.parent, os.O_RDONLY | os.O_DIRECTORY) + try: + os.fsync(descriptor) + finally: + os.close(descriptor) + + +def check_container(deploy, config, env_file, mode): + compose = deploy.compose_command(env_file, mode) + ids = run(compose + ["ps", "-a", "-q", "moyi-api"], cwd=deploy.HERE).splitlines() + require(len(ids) == 1, "Expected one existing API container in this Compose project.") + item = json.loads(run(["docker", "inspect", ids[0]]))[0] + labels = item["Config"]["Labels"] + require(Path(labels["com.docker.compose.project.working_dir"]).resolve() == deploy.HERE.resolve(), + "Container belongs to another release directory.") + require(item["Config"]["Image"] == config["services"]["moyi-api"]["image"], + "Running image differs from deployment configuration.") + actual = dict(value.split("=", 1) for value in item["Config"]["Env"] if "=" in value) + expected = config["services"]["moyi-api"]["environment"] + for key in ("SPRING_DATASOURCE_URL", "SPRING_DATASOURCE_USERNAME", "SPRING_DATASOURCE_PASSWORD", + "AUTH_PASSWORD_PEPPER", "CREDENTIAL_ENCRYPTION_KEY"): + require(actual.get(key) == expected.get(key), "Container/database or encryption settings differ; refusing reset.") + return ids[0], compose + + +def apply_change(deploy, config, env_file, mode, account, password, database, psql, pg_dump, backup_root): + api = config["services"]["moyi-api"]["environment"] + pg_env = postgres_environment(api, database) + owner = read_owner(psql, pg_env, api["ADMIN_ACCOUNT"], account) + container, compose = check_container(deploy, config, env_file, mode) + original = env_file.read_bytes() + content = updated_environment(original.decode("utf-8-sig"), account, password).encode("utf-8") + backup_root.mkdir(mode=0o700, parents=True, exist_ok=True) + backup = Path(tempfile.mkdtemp(prefix="owner-reset-", dir=backup_root)) + write_private(backup / "env.cloud.before", original) + write_private(backup / "env.cloud.after", content) + staged = deploy.load_config(backup / "env.cloud.after", mode) + deploy.validate_config(staged, mode) + validate_staged_config(config, staged, account, password) + print("Private recovery directory: " + str(backup), flush=True) + print("Stopping API for backup and session revocation...", flush=True) + mutation_started = False + try: + run(["docker", "stop", "--time", "40", container]) + require(env_file.read_bytes() == original, "Environment file changed concurrently; refusing reset.") + dump = backup / "moyi_control.dump" + run([pg_dump, "--no-password", "--format=custom", "--quote-all-identifiers", "--lock-wait-timeout=10000", + "--file=" + str(dump)], env=pg_env) + require(dump.stat().st_size > 0, "Database backup is empty.") + with dump.open("rb") as stream: + digest = hashlib.file_digest(stream, "sha256").hexdigest() + write_private(backup / "moyi_control.dump.sha256", (digest + " moyi_control.dump\n").encode("ascii")) + encoded = password_hash(password, api["AUTH_PASSWORD_PEPPER"]) + mutation_started = True + result = query_database(psql, pg_env, reset_sql(database, owner, account, encoded)) + require(result == "OWNER_RESET_COMMITTED", "Database outcome uncertain; keep API stopped and rerun this tool.") + install_environment(env_file, content) + run(compose + ["up", "-d", "--no-deps", "--no-build", "--pull", "never", "--force-recreate", + "--wait", "--wait-timeout", "180", "moyi-api"], cwd=deploy.HERE) + run(compose + ["exec", "-T", "frontend", "nginx", "-t"], cwd=deploy.HERE) + run(compose + ["exec", "-T", "frontend", "nginx", "-s", "reload"], cwd=deploy.HERE) + deploy.smoke(staged, mode, login=True) + except BaseException: + if not mutation_started: + run(["docker", "start", container]) + print("Reset was not attempted; original API container restarted.", flush=True) + else: + print("Maintenance did not finish. Do not restore the old env or database blindly. " + "Rerun this tool with the same account/password to reconcile and verify. Recovery: " + str(backup), flush=True) + raise + print("SUPER_ADMIN_RESET_OK: " + account + "; existing user ID preserved; previous sessions revoked.") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--deployment-dir", type=Path, required=True) + parser.add_argument("--account", required=True) + parser.add_argument("--database", default="moyi_control") + parser.add_argument("--mode", choices=("https", "tunnel"), default="https") + parser.add_argument("--backup-root", type=Path, default=Path("/opt/moyi/backups")) + parser.add_argument("--apply", action="store_true", help="Stop API, back up, reset owner and restart; password is prompted twice") + args = parser.parse_args() + require(re.fullmatch(r"[A-Za-z][A-Za-z0-9_]{0,79}", args.account), "Use an ASCII username starting with a letter.") + require(re.fullmatch(r"[a-z][a-z0-9_]+", args.database) and args.database not in ("postgres", "template0", "template1"), + "Use a dedicated application database.") + require(not args.apply or (os.name == "posix" and os.geteuid() == 0), "Apply must run as root on the Linux server.") + directory = args.deployment_dir.resolve() + spec = importlib.util.spec_from_file_location("moyi_deploy", directory / "deploy.py") + deploy = importlib.util.module_from_spec(spec) + spec.loader.exec_module(deploy) + env_file = directory / ".env.cloud" + psql, pg_dump = shutil.which("psql"), shutil.which("pg_dump") + require(psql and pg_dump, "Install postgresql-client first.") + if args.apply: + import fcntl + os.umask(0o077) + lock = open(directory / ".owner-maintenance.lock", "a") + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + config = deploy.preflight(env_file, args.mode) + api = config["services"]["moyi-api"]["environment"] + env = postgres_environment(api, args.database) + owner = read_owner(psql, env, api["ADMIN_ACCOUNT"], args.account) + check_container(deploy, config, env_file, args.mode) + print("Database: " + args.database + "; existing super administrator: " + owner["account"]) + if not args.apply: + print("Read-only check passed. Add --apply to change credentials.") + return + require(sys.stdin.isatty(), "Run interactively in SSH, not through a heredoc or pipe.") + password = getpass.getpass("New super administrator password (hidden): ") + require(password == getpass.getpass("Repeat new password (hidden): "), "Passwords do not match; nothing changed.") + apply_change(deploy, config, env_file, args.mode, args.account, password, args.database, + psql, pg_dump, args.backup_root.resolve()) + + +if __name__ == "__main__": + try: + main() + except (MaintenanceError, ValueError, OSError, subprocess.SubprocessError, KeyboardInterrupt) as error: + message = str(error) if isinstance(error, MaintenanceError) else type(error).__name__ + ": maintenance stopped; no secret output shown." + print("ERROR: " + message, file=sys.stderr) + sys.exit(1) diff --git a/infra/moyi/backup_database.py b/infra/moyi/backup_database.py new file mode 100644 index 0000000..5eb6dbe --- /dev/null +++ b/infra/moyi/backup_database.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python3 +"""Back up the running MOYI database and its configuration before an upgrade.""" +import argparse +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +from datetime import datetime, timezone + +from admin_credentials import MaintenanceError, check_container, postgres_environment, require, run, write_private + + +def backup(deploy, mode, output_root, database="moyi_control"): + require(database == "moyi_control", "This upgrade backup is restricted to moyi_control.") + programs = {name: shutil.which(name) for name in ("psql", "pg_dump", "pg_restore")} + require(all(programs.values()), "Install postgresql-client before backing up.") + env_file = deploy.HERE / ".env.cloud" + config = deploy.preflight(env_file, mode) + check_container(deploy, config, env_file, mode) + pg_env = postgres_environment(config["services"]["moyi-api"]["environment"], database) + actual = run([programs["psql"], "-X", "--no-password", "-qAt", "-v", "ON_ERROR_STOP=1", + "-c", "SELECT current_database()"], env=pg_env) + require(actual == database, "Connected database does not match moyi_control.") + original = env_file.read_bytes() + output_root.mkdir(mode=0o700, parents=True, exist_ok=True) + destination = Path(tempfile.mkdtemp(prefix="pre-upgrade-", dir=output_root)) + print("Private backup directory: " + str(destination), flush=True) + write_private(destination / "env.cloud", original) + if mode == "https": + for name in ("fullchain.pem", "privkey.pem"): + write_private(destination / name, (deploy.HERE / "certs" / name).read_bytes()) + dump = destination / "moyi_control.dump" + run([programs["pg_dump"], "--no-password", "--format=custom", "--quote-all-identifiers", + "--lock-wait-timeout=10000", "--file=" + str(dump)], env=pg_env) + require(dump.is_file() and dump.stat().st_size > 0, "Database backup is empty.") + # Read/decompress the whole archive without connecting to any database. + run([programs["pg_restore"], "--file=" + os.devnull, str(dump)]) + require(env_file.read_bytes() == original, "Configuration changed during backup; repeat the backup.") + digests = {} + for item in destination.iterdir(): + with item.open("rb") as stream: + digests[item.name] = hashlib.file_digest(stream, "sha256").hexdigest() + write_private(destination / "SHA256SUMS", "".join( + value + " " + name + "\n" for name, value in sorted(digests.items())).encode("ascii")) + # This marker is written only after export and full archive validation succeed. + write_private(destination / "backup-complete.json", json.dumps({ + "database": database, "deployment": str(deploy.HERE), + "completedAt": datetime.now(timezone.utc).isoformat(), "sha256": digests, + }, indent=2).encode("utf-8")) + print("BACKUP_OK: moyi_control exported; archive read successfully; credentials not printed.") + return destination + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--deployment-dir", type=Path, required=True) + parser.add_argument("--mode", choices=("https", "tunnel"), default="https") + parser.add_argument("--output-root", type=Path, default=Path("/opt/moyi/backups")) + args = parser.parse_args() + os.umask(0o077) + directory = args.deployment_dir.resolve() + spec = importlib.util.spec_from_file_location("running_moyi_deploy", directory / "deploy.py") + deploy = importlib.util.module_from_spec(spec) + spec.loader.exec_module(deploy) + backup(deploy, args.mode, args.output_root.resolve()) + + +if __name__ == "__main__": + try: + main() + except (MaintenanceError, ValueError, OSError, subprocess.SubprocessError) as error: + message = str(error) if isinstance(error, MaintenanceError) else type(error).__name__ + ": backup failed; no secret output shown." + print("ERROR: " + message, file=sys.stderr) + sys.exit(1) diff --git a/infra/moyi/docker-compose.cloud.yml b/infra/moyi/docker-compose.cloud.yml index bf67aac..2b66c4c 100644 --- a/infra/moyi/docker-compose.cloud.yml +++ b/infra/moyi/docker-compose.cloud.yml @@ -32,6 +32,17 @@ services: ADMIN_PASSWORD: ${ADMIN_PASSWORD:?Set a strong initial admin password} ADMIN_DISPLAY_NAME: ${ADMIN_DISPLAY_NAME:-MOYI Admin} SESSION_TTL_HOURS: ${SESSION_TTL_HOURS:-168} + MOYI_SMTP_HOST: ${MOYI_SMTP_HOST:-} + MOYI_SMTP_PORT: ${MOYI_SMTP_PORT:-465} + MOYI_SMTP_FROM: ${MOYI_SMTP_FROM:-} + MOYI_SMTP_USERNAME: ${MOYI_SMTP_USERNAME:-} + MOYI_SMTP_PASSWORD: ${MOYI_SMTP_PASSWORD:-} + MOYI_SMTP_SSL: ${MOYI_SMTP_SSL:-true} + MOYI_SMTP_STARTTLS: ${MOYI_SMTP_STARTTLS:-false} + MOYI_SMS_ACCESS_KEY_ID: ${MOYI_SMS_ACCESS_KEY_ID:-} + MOYI_SMS_ACCESS_KEY_SECRET: ${MOYI_SMS_ACCESS_KEY_SECRET:-} + MOYI_SMS_SIGN_NAME: ${MOYI_SMS_SIGN_NAME:-} + MOYI_SMS_TEMPLATE_CODE: ${MOYI_SMS_TEMPLATE_CODE:-} GATEWAY_REQUESTS_PER_MINUTE: ${GATEWAY_REQUESTS_PER_MINUTE:-60} GATEWAY_READS_PER_MINUTE: ${GATEWAY_READS_PER_MINUTE:-300} GATEWAY_DEFAULT_MODEL_CONCURRENCY: ${GATEWAY_DEFAULT_MODEL_CONCURRENCY:-4} diff --git a/infra/moyi/nginx/routes.conf b/infra/moyi/nginx/routes.conf index 14d2d1a..0beaf8d 100644 --- a/infra/moyi/nginx/routes.conf +++ b/infra/moyi/nginx/routes.conf @@ -17,6 +17,7 @@ location /api/ { proxy_set_header Host $http_host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $remote_addr; + proxy_set_header Forwarded ""; proxy_set_header X-Forwarded-Proto $scheme; proxy_connect_timeout 5s; proxy_read_timeout 120s; @@ -28,6 +29,7 @@ location /v1/ { proxy_set_header Host $http_host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $remote_addr; + proxy_set_header Forwarded ""; proxy_set_header X-Forwarded-Proto $scheme; proxy_set_header Connection ""; proxy_buffering off; diff --git a/infra/moyi/tests/test_admin_credentials.py b/infra/moyi/tests/test_admin_credentials.py new file mode 100644 index 0000000..09420d7 --- /dev/null +++ b/infra/moyi/tests/test_admin_credentials.py @@ -0,0 +1,246 @@ +import base64 +import contextlib +import hashlib +import importlib.util +import io +import json +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +from types import SimpleNamespace +import unittest +from unittest.mock import patch +import uuid + +from test_deploy import configuration, deploy, DIRECTORY + +SPEC = importlib.util.spec_from_file_location("admin_credentials", DIRECTORY / "admin_credentials.py") +maintenance = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(maintenance) + + +class CredentialMaintenanceTests(unittest.TestCase): + def test_password_format_matches_java_parameters(self): + for password in ("x", "Test42!", "a'b\\c$#\"", "\u6d4b\u8bd5A1!"): + with self.subTest(password=password): + encoded = maintenance.password_hash(password, "local-test-pepper") + name, iterations, salt, key = encoded.split("$") + self.assertEqual((name, iterations), ("pbkdf2", "210000")) + salt = base64.urlsafe_b64decode(salt + "==") + self.assertEqual(len(salt), 16) + actual = base64.urlsafe_b64decode(key + "=") + self.assertEqual(len(actual), 32) + expected = hashlib.pbkdf2_hmac("sha256", (password + "local-test-pepper").encode(), salt, 210000, 32) + self.assertEqual(expected, actual) + self.assertNotEqual(encoded, maintenance.password_hash(password, "local-test-pepper")) + + def test_no_password_minimum_but_rejects_blank_and_control_characters(self): + self.assertIn('ADMIN_PASSWORD="x"', maintenance.updated_environment("OTHER=value\n", "Owner", "x")) + for password in ("", " ", "bad\nline", "bad\x00null", "admin123"): + with self.subTest(password=password), self.assertRaises(maintenance.MaintenanceError): + maintenance.updated_environment("OTHER=value\n", "Owner", password) + + def test_database_target_guard_and_no_password_in_argv(self): + api = configuration()["services"]["moyi-api"]["environment"] + env = maintenance.postgres_environment(api, "moyi_control") + self.assertEqual(env["PGDATABASE"], "moyi_control") + with patch.object(maintenance, "run", return_value="ok") as runner: + maintenance.query_database("psql", env, "SELECT 1;") + args, kwargs = runner.call_args + self.assertNotIn(api["SPRING_DATASOURCE_PASSWORD"], " ".join(args[0])) + self.assertEqual(kwargs["env"]["PGPASSWORD"], api["SPRING_DATASOURCE_PASSWORD"]) + with self.assertRaisesRegex(maintenance.MaintenanceError, "target"): + maintenance.postgres_environment(api, "other_app") + api["SPRING_DATASOURCE_URL"] += "?sslmode=verify-full&sslrootcert=%2Fopt%2Fmoyi%2Fca.pem" + env = maintenance.postgres_environment(api, "moyi_control") + self.assertEqual(env["PGSSLMODE"], "verify-full") + self.assertEqual(env["PGSSLROOTCERT"], "/opt/moyi/ca.pem") + api["SPRING_DATASOURCE_URL"] += "&unknown=unsafe" + with self.assertRaisesRegex(maintenance.MaintenanceError, "Unsupported"): + maintenance.postgres_environment(api, "moyi_control") + + def test_secret_tool_errors_are_not_echoed_and_stdin_is_not_inherited(self): + with patch.object(maintenance.subprocess, "run", return_value=SimpleNamespace(returncode=1, stdout="secret", stderr="secret")) as runner: + with self.assertRaises(maintenance.MaintenanceError) as error: + maintenance.run(["docker", "compose"]) + self.assertNotIn("secret", str(error.exception)) + self.assertEqual(runner.call_args.kwargs["stdin"], subprocess.DEVNULL) + + def test_owner_check_and_recovery_after_commit(self): + owner = {"id": str(uuid.uuid4()), "account": "adimin", "status": "active"} + for rows in ([], [owner, owner], [{**owner, "status": "disabled"}], [{**owner, "account": "other"}]): + with patch.object(maintenance, "query_database", return_value=json.dumps(rows)): + with self.assertRaises(maintenance.MaintenanceError): + maintenance.read_owner("psql", {}, "adimin", "NewOwner") + for account in ("adimin", "newowner"): + with patch.object(maintenance, "query_database", side_effect=[json.dumps([{**owner, "account": account}]), "0"]): + self.assertEqual(maintenance.read_owner("psql", {}, "adimin", "NewOwner")["id"], owner["id"]) + with patch.object(maintenance, "query_database", side_effect=[json.dumps([owner]), "1"]): + with self.assertRaisesRegex(maintenance.MaintenanceError, "already used"): + maintenance.read_owner("psql", {}, "adimin", "NewOwner") + + def test_config_change_guard_preserves_other_settings(self): + before = configuration() + after = json.loads(json.dumps(before)) + after["services"]["moyi-api"]["environment"].update(ADMIN_ACCOUNT="Owner", ADMIN_PASSWORD="x") + maintenance.validate_staged_config(before, after, "Owner", "x") + after["services"]["moyi-api"]["environment"]["AUTH_PASSWORD_PEPPER"] = "changed" + with self.assertRaises(maintenance.MaintenanceError): + maintenance.validate_staged_config(before, after, "Owner", "x") + + def test_environment_install_is_atomic(self): + with tempfile.TemporaryDirectory() as directory: + path = Path(directory) / ".env.cloud" + path.write_bytes(b"before") + with patch.object(maintenance.os, "replace", side_effect=OSError("test")): + with self.assertRaises(OSError): + maintenance.install_environment(path, b"after") + self.assertEqual(path.read_bytes(), b"before") + maintenance.install_environment(path, b"after") + self.assertEqual(path.read_bytes(), b"after") + + @unittest.skipUnless(shutil.which("docker"), "Docker CLI required") + def test_real_compose_password_quoting_preserves_every_other_setting(self): + text = (DIRECTORY / ".env.cloud.example").read_text(encoding="utf-8") + for old, new in {"CHANGE_ME_RDS_HOST": "rds.internal", "CHANGE_ME_RDS_PASSWORD": "test-db", + "CHANGE_ME_TAIR_HOST": "redis.internal", "CHANGE_ME_TAIR_PASSWORD": "test-cache", + "GENERATE_AUTH_PEPPER": "p" * 64, "GENERATE_CREDENTIAL_KEY": "k" * 64, + "GENERATE_ADMIN_PASSWORD": "test-admin"}.items(): + text = text.replace(old, new) + with tempfile.TemporaryDirectory() as directory: + path = Path(directory) / ".env.cloud" + maintenance.write_private(path, text.encode()) + before = deploy.load_config(path, "https") + for password in ("x", "Test42!", "a'b\\c$#\"", "end\\", "$$literal${HOME}", "\u6d4b\u8bd5A1!", " spaced "): + with self.subTest(password=password): + path.write_text(maintenance.updated_environment(text, "TestOwner", password), encoding="utf-8") + after = deploy.load_config(path, "https") + maintenance.validate_staged_config(before, after, "TestOwner", password) + + +@unittest.skipUnless(os.environ.get("MOYI_CREDENTIAL_TEST_PG_BIN"), "Isolated local PostgreSQL required") +class CredentialDatabaseTests(unittest.TestCase): + def setUp(self): + self.psql = str(Path(os.environ["MOYI_CREDENTIAL_TEST_PG_BIN"]) / "psql.exe") + self.name = "moyi_credentials_test_" + uuid.uuid4().hex + self.env = {key: value for key, value in os.environ.items() if not key.startswith("PG")} + self.env.update(PGHOST="127.0.0.1", PGPORT="55439", PGUSER="moyi_role_test", PGDATABASE="moyi_role_test") + maintenance.query_database(self.psql, self.env, 'CREATE DATABASE "' + self.name + '";') + self.env["PGDATABASE"] = self.name + repo = DIRECTORY.parents[1] + migrations = repo / "control-plane-java/src/main/resources/db/migration" + maintenance.query_database(self.psql, self.env, (migrations / "V1__auth.sql").read_text() + (migrations / "V9__admin_roles.sql").read_text()) + self.owner = {"id": str(uuid.uuid4()), "account": "oldowner", "status": "active"} + self.other = str(uuid.uuid4()) + self.session = str(uuid.uuid4()) + self.other_session = str(uuid.uuid4()) + maintenance.query_database(self.psql, self.env, f""" +INSERT INTO public.users (id, account, account_kind, password_hash, display_name, role) VALUES +('{self.owner['id']}', 'oldowner', 'username', 'old-hash', 'Original name', 'super_admin'), +('{self.other}', 'ordinary', 'username', 'other-hash', 'Other name', 'user'); +INSERT INTO public.auth_sessions (id, token_hash, user_id, expires_at) VALUES +('{self.session}', 'owner-token', '{self.owner['id']}', now() + interval '1 day'), +('{self.other_session}', 'other-token', '{self.other}', now() + interval '1 day'); +INSERT INTO public.invitation_codes (id, code_hash, code_prefix, label, created_by) VALUES +('{uuid.uuid4()}', 'invite-hash', 'invite', 'Owner relation', '{self.owner['id']}'); +""") + + def tearDown(self): + self.env["PGDATABASE"] = "moyi_role_test" + maintenance.query_database(self.psql, self.env, 'DROP DATABASE "' + self.name + '";') + + def query(self, sql): + return maintenance.query_database(self.psql, self.env, sql) + + def test_reset_preserves_identity_relations_other_users_and_revokes_owner_sessions(self): + encoded = maintenance.password_hash("Test42!", "local-test-pepper") + self.assertEqual(self.query(maintenance.reset_sql(self.name, self.owner, "NewOwner", encoded)), "OWNER_RESET_COMMITTED") + data = json.loads(self.query("SELECT row_to_json(u) FROM public.users u WHERE role = 'super_admin'")) + self.assertEqual(data["id"], self.owner["id"]) + self.assertEqual(data["account"], "newowner") + self.assertEqual(data["password_hash"], encoded) + self.assertEqual(data["display_name"], "Original name") + self.assertEqual(self.query("SELECT count(*) FROM public.users"), "2") + self.assertEqual(self.query("SELECT created_by FROM public.invitation_codes"), self.owner["id"]) + self.assertEqual(self.query(f"SELECT revoked_at IS NOT NULL FROM public.auth_sessions WHERE id = '{self.session}'"), "t") + self.assertEqual(self.query(f"SELECT revoked_at IS NULL FROM public.auth_sessions WHERE id = '{self.other_session}'"), "t") + self.assertEqual(self.query(f"SELECT password_hash FROM public.users WHERE id = '{self.other}'"), "other-hash") + details = self.query("SELECT details FROM public.auth_audit_log WHERE event_type = 'user.credentials_reset'") + self.assertNotIn("password", details) + self.assertNotIn(encoded, details) + self.assertIn("newowner", details) + current = maintenance.read_owner(self.psql, self.env, "oldowner", "NewOwner") + self.assertEqual(self.query(maintenance.reset_sql(self.name, current, "NewOwner", encoded)), "OWNER_RESET_COMMITTED") + + def test_conflict_wrong_database_and_owner_drift_leave_everything_unchanged(self): + for database, owner, account in ((self.name, self.owner, "ordinary"), ("wrong_database", self.owner, "NewOwner"), + (self.name, {**self.owner, "account": "changed"}, "NewOwner")): + with self.subTest(database=database, account=account): + with self.assertRaises(maintenance.MaintenanceError): + self.query(maintenance.reset_sql(database, owner, account, "new-hash")) + self.assertEqual(self.query("SELECT account FROM public.users WHERE role = 'super_admin'"), "oldowner") + self.assertEqual(self.query("SELECT count(*) FROM public.auth_audit_log"), "0") + self.assertEqual(self.query("SELECT count(*) FROM public.auth_sessions WHERE revoked_at IS NOT NULL"), "0") + + def test_audit_failure_rolls_back_password_and_session_changes(self): + self.query("ALTER TABLE public.auth_audit_log ADD CONSTRAINT test_reject_audit CHECK (event_type <> 'user.credentials_reset')") + with self.assertRaises(maintenance.MaintenanceError): + self.query(maintenance.reset_sql(self.name, self.owner, "NewOwner", "new-hash")) + self.assertEqual(self.query("SELECT password_hash FROM public.users WHERE role = 'super_admin'"), "old-hash") + self.assertEqual(self.query("SELECT count(*) FROM public.auth_sessions WHERE revoked_at IS NOT NULL"), "0") + + @unittest.skipUnless(shutil.which("docker"), "Docker CLI required for config parsing only") + def test_real_backup_and_recovery_when_env_install_fails_after_commit(self): + text = (DIRECTORY / ".env.cloud.example").read_text(encoding="utf-8") + for old, new in {"jdbc:postgresql://CHANGE_ME_RDS_HOST:5432/moyi_control": "jdbc:postgresql://127.0.0.1:55439/" + self.name, + "MOYI_DB_USERNAME=moyi_app": "MOYI_DB_USERNAME=moyi_role_test", "CHANGE_ME_RDS_PASSWORD": "test-only", + "CHANGE_ME_TAIR_HOST": "redis.internal", "CHANGE_ME_TAIR_PASSWORD": "test-cache", + "GENERATE_AUTH_PEPPER": "p" * 64, "GENERATE_CREDENTIAL_KEY": "k" * 64, + "GENERATE_ADMIN_PASSWORD": "test-admin", "ADMIN_ACCOUNT=adimin": "ADMIN_ACCOUNT=oldowner"}.items(): + text = text.replace(old, new) + pg_dump = str(Path(self.psql).with_name("pg_dump.exe")) + real_run = maintenance.run + docker_calls = [] + + def run_command(command, **kwargs): + if command[0] == "docker": + docker_calls.append(command) + return "" + return real_run(command, **kwargs) + + with tempfile.TemporaryDirectory() as temporary: + path = Path(temporary) / ".env.cloud" + backups = Path(temporary) / "backups" + maintenance.write_private(path, text.encode()) + cfg = deploy.load_config(path, "https") + with patch.object(maintenance, "check_container", return_value=("test-container", ["docker", "compose"])), \ + patch.object(maintenance, "run", side_effect=run_command), patch.object(deploy, "smoke") as smoke, \ + contextlib.redirect_stdout(io.StringIO()): + with patch.object(maintenance, "install_environment", side_effect=OSError("injected failure")): + with self.assertRaises(OSError): + maintenance.apply_change(deploy, cfg, path, "https", "NewOwner", "x", self.name, + self.psql, pg_dump, backups) + self.assertEqual(path.read_bytes(), text.encode()) + self.assertEqual(self.query("SELECT account FROM public.users WHERE role = 'super_admin'"), "newowner") + self.assertFalse(any(call[1] == "start" or "up" in call for call in docker_calls)) + smoke.assert_not_called() + backup = next(backups.glob("owner-reset-*")) + pg_restore = str(Path(self.psql).with_name("pg_restore.exe")) + listing = real_run([pg_restore, "--list", str(backup / "moyi_control.dump")]) + self.assertIn("TABLE DATA public users", listing) + real_run([pg_restore, "--file=" + os.devnull, str(backup / "moyi_control.dump")]) + maintenance.apply_change(deploy, cfg, path, "https", "NewOwner", "x", self.name, + self.psql, pg_dump, backups) + smoke.assert_called_once() + self.assertTrue(smoke.call_args.kwargs["login"]) + final = deploy.load_config(path, "https") + maintenance.validate_staged_config(cfg, final, "NewOwner", "x") + self.assertEqual(self.query("SELECT count(*) FROM public.users WHERE role = 'super_admin'"), "1") + self.assertEqual(self.query("SELECT id FROM public.users WHERE role = 'super_admin'"), self.owner["id"]) + self.assertTrue(any("--force-recreate" in call and "--no-build" in call for call in docker_calls)) + + +if __name__ == "__main__": + unittest.main() diff --git a/infra/moyi/tests/test_backup_database.py b/infra/moyi/tests/test_backup_database.py new file mode 100644 index 0000000..4b283e8 --- /dev/null +++ b/infra/moyi/tests/test_backup_database.py @@ -0,0 +1,66 @@ +import importlib.util +import json +from pathlib import Path +import sys +import tempfile +from types import SimpleNamespace +import unittest +from unittest.mock import patch + +from test_deploy import configuration, DIRECTORY + +sys.path.insert(0, str(DIRECTORY)) +SPEC = importlib.util.spec_from_file_location("backup_database", DIRECTORY / "backup_database.py") +backup_database = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(backup_database) + + +class BackupTests(unittest.TestCase): + def test_wrong_database_is_rejected_before_export(self): + with tempfile.TemporaryDirectory() as root: + config = configuration() + config["services"]["moyi-api"]["environment"]["SPRING_DATASOURCE_URL"] = "jdbc:postgresql://rds.internal:5432/another_app" + deploy = SimpleNamespace(HERE=Path(root), preflight=lambda *args: config) + with patch.object(backup_database.shutil, "which", side_effect=lambda name: name), \ + patch.object(backup_database, "check_container"), \ + patch.object(backup_database, "run") as command: + with self.assertRaisesRegex(backup_database.MaintenanceError, "target"): + backup_database.backup(deploy, "tunnel", Path(root) / "backups") + command.assert_not_called() + + def test_complete_marker_requires_successful_archive_validation(self): + for corrupt in (False, True): + with self.subTest(corrupt=corrupt), tempfile.TemporaryDirectory() as root: + directory = Path(root) + (directory / ".env.cloud").write_text("MOYI_SMTP_PASSWORD='test-only-secret'\n") + deploy = SimpleNamespace(HERE=directory, preflight=lambda *args: configuration()) + seen = [] + + def command(argv, **kwargs): + seen.append(argv) + self.assertNotIn("test-only-rds-password", " ".join(argv)) + if argv[0] == "psql": + return "moyi_control" + if argv[0] == "pg_dump": + Path(next(item[7:] for item in argv if item.startswith("--file="))).write_bytes(b"test archive") + if argv[0] == "pg_restore" and corrupt: + raise backup_database.MaintenanceError("Invalid archive") + return "" + + with patch.object(backup_database.shutil, "which", side_effect=lambda name: name), \ + patch.object(backup_database, "check_container"), patch.object(backup_database, "run", side_effect=command): + if corrupt: + with self.assertRaisesRegex(backup_database.MaintenanceError, "Invalid archive"): + backup_database.backup(deploy, "tunnel", directory / "backups") + self.assertEqual([], list((directory / "backups").rglob("backup-complete.json"))) + else: + destination = backup_database.backup(deploy, "tunnel", directory / "backups") + report = json.loads((destination / "backup-complete.json").read_text()) + self.assertEqual(report["database"], "moyi_control") + self.assertEqual((destination / "env.cloud").read_bytes(), (directory / ".env.cloud").read_bytes()) + self.assertEqual(set(report["sha256"]), {"env.cloud", "moyi_control.dump"}) + self.assertEqual([argv[0] for argv in seen], ["psql", "pg_dump", "pg_restore"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/infra/moyi/tests/test_deploy.py b/infra/moyi/tests/test_deploy.py index cfa3aec..ec8d3ff 100644 --- a/infra/moyi/tests/test_deploy.py +++ b/infra/moyi/tests/test_deploy.py @@ -37,6 +37,12 @@ def configuration(): class DeploymentTests(unittest.TestCase): + def test_proxy_replaces_forwarding_headers_for_verification_limits(self): + routes = (DIRECTORY / "nginx" / "routes.conf").read_text(encoding="utf-8") + self.assertEqual(routes.count('proxy_set_header Forwarded "";'), 2) + self.assertEqual(routes.count('proxy_set_header X-Forwarded-For $remote_addr;'), 2) + self.assertNotIn('$proxy_add_x_forwarded_for', routes) + def test_login_smoke_requires_super_admin_and_checks_management(self): cfg = configuration() cfg["services"]["moyi-api"]["environment"]["ADMIN_ACCOUNT"] = "adimin" diff --git a/prototype/nginx.conf b/prototype/nginx.conf index fd0cf9e..a440acf 100644 --- a/prototype/nginx.conf +++ b/prototype/nginx.conf @@ -10,7 +10,8 @@ server { proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; - proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-For $remote_addr; + proxy_set_header Forwarded ""; proxy_set_header X-Forwarded-Proto $scheme; proxy_set_header Cookie $http_cookie; } @@ -20,7 +21,8 @@ server { proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; - proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-For $remote_addr; + proxy_set_header Forwarded ""; proxy_set_header X-Forwarded-Proto $scheme; proxy_set_header Authorization $http_authorization; proxy_set_header Content-Type $http_content_type; diff --git a/prototype/src/App.vue b/prototype/src/App.vue index 97ad954..9492798 100644 --- a/prototype/src/App.vue +++ b/prototype/src/App.vue @@ -29,6 +29,7 @@ const authenticated = ref(false) const authUser = ref() const accountMenuOpen = ref(false) const userName = ref('') +const availableCredit = ref() onMounted(async () => { try { @@ -80,6 +81,7 @@ function signIn(user: AuthUser) { } function logout() { + availableCredit.value = undefined accountMenuOpen.value = false portal.value = 'user' activeView.value = 'overview' @@ -130,9 +132,9 @@ function openAccountSettings() { diff --git a/prototype/src/components/AccountAdmin.vue b/prototype/src/components/AccountAdmin.vue new file mode 100644 index 0000000..c0f8c44 --- /dev/null +++ b/prototype/src/components/AccountAdmin.vue @@ -0,0 +1,106 @@ + + +