github.com/infraboard/keyauth@v0.8.1/apps/user/http/sub.go (about)

     1  package http
     2  
     3  import (
     4  	"net/http"
     5  
     6  	"github.com/infraboard/mcube/exception"
     7  	"github.com/infraboard/mcube/http/context"
     8  	"github.com/infraboard/mcube/http/request"
     9  	"github.com/infraboard/mcube/http/response"
    10  
    11  	"github.com/infraboard/keyauth/apps/token"
    12  	"github.com/infraboard/keyauth/apps/user"
    13  	"github.com/infraboard/keyauth/apps/user/types"
    14  )
    15  
    16  func (h *handler) CreateSubAccount(w http.ResponseWriter, r *http.Request) {
    17  	ctx := context.GetContext(r)
    18  	tk := ctx.AuthInfo.(*token.Token)
    19  
    20  	req := user.NewCreateUserRequest()
    21  	req.Domain = tk.Domain
    22  	if err := request.GetDataFromRequest(r, req); err != nil {
    23  		response.Failed(w, err)
    24  		return
    25  	}
    26  
    27  	if req.UserType >= tk.UserType {
    28  		response.Failed(w, exception.NewPermissionDeny(
    29  			"不能创建高于自身权限的用户, 创建人权限: %s, 被创建人权限: %s", req.UserType, tk.UserType))
    30  		return
    31  	}
    32  
    33  	req.CreateType = user.CreateType_DOMAIN_CREATED
    34  
    35  	d, err := h.service.CreateAccount(
    36  		r.Context(),
    37  		req,
    38  	)
    39  	if err != nil {
    40  		response.Failed(w, err)
    41  		return
    42  	}
    43  
    44  	response.Success(w, d)
    45  }
    46  
    47  func (h *handler) QuerySubAccount(w http.ResponseWriter, r *http.Request) {
    48  	ctx := context.GetContext(r)
    49  	tk := ctx.AuthInfo.(*token.Token)
    50  
    51  	req := user.NewNewQueryAccountRequestFromHTTP(r)
    52  	req.UserType = types.UserType_SUB
    53  	req.Domain = tk.Domain
    54  
    55  	d, err := h.service.QueryAccount(
    56  		r.Context(),
    57  		req,
    58  	)
    59  	if err != nil {
    60  		response.Failed(w, err)
    61  		return
    62  	}
    63  
    64  	response.Success(w, d)
    65  }
    66  
    67  func (h *handler) DescribeSubAccount(w http.ResponseWriter, r *http.Request) {
    68  	rctx := context.GetContext(r)
    69  	req := user.NewDescriptAccountRequestWithAccount(rctx.PS.ByName("account"))
    70  
    71  	d, err := h.service.DescribeAccount(r.Context(), req)
    72  	if err != nil {
    73  		response.Failed(w, err)
    74  		return
    75  	}
    76  
    77  	response.Success(w, d)
    78  }
    79  
    80  func (h *handler) PatchSubAccount(w http.ResponseWriter, r *http.Request) {
    81  	rctx := context.GetContext(r)
    82  	req := user.NewPatchAccountRequest()
    83  	req.Account = rctx.PS.ByName("account")
    84  
    85  	if err := request.GetDataFromRequest(r, req.Profile); err != nil {
    86  		response.Failed(w, err)
    87  		return
    88  	}
    89  
    90  	ins, err := h.service.UpdateAccountProfile(r.Context(), req)
    91  	if err != nil {
    92  		response.Failed(w, err)
    93  		return
    94  	}
    95  	ins.Desensitize()
    96  
    97  	response.Success(w, ins)
    98  	return
    99  }
   100  
   101  // DestroySubAccount 注销账号
   102  func (h *handler) DestroySubAccount(w http.ResponseWriter, r *http.Request) {
   103  	rctx := context.GetContext(r)
   104  	req := &user.DeleteAccountRequest{Account: rctx.PS.ByName("account")}
   105  
   106  	_, err := h.service.DeleteAccount(
   107  		r.Context(),
   108  		req,
   109  	)
   110  	if err != nil {
   111  		response.Failed(w, err)
   112  		return
   113  	}
   114  
   115  	response.Success(w, "delete ok")
   116  }
   117  
   118  func (h *handler) BlockSubAccount(w http.ResponseWriter, r *http.Request) {
   119  	req := user.NewBlockAccountRequest("", "")
   120  	if err := request.GetDataFromRequest(r, req); err != nil {
   121  		response.Failed(w, err)
   122  		return
   123  	}
   124  
   125  	ins, err := h.service.BlockAccount(
   126  		r.Context(),
   127  		req,
   128  	)
   129  	if err != nil {
   130  		response.Failed(w, err)
   131  		return
   132  	}
   133  	ins.Desensitize()
   134  
   135  	response.Success(w, ins)
   136  }
   137  
   138  func (h *handler) UnBlockSubAccount(w http.ResponseWriter, r *http.Request) {
   139  	req := user.NewBlockAccountRequest("", "")
   140  	if err := request.GetDataFromRequest(r, req); err != nil {
   141  		response.Failed(w, err)
   142  		return
   143  	}
   144  
   145  	ins, err := h.service.BlockAccount(
   146  		r.Context(),
   147  		req,
   148  	)
   149  	if err != nil {
   150  		response.Failed(w, err)
   151  		return
   152  	}
   153  	ins.Desensitize()
   154  
   155  	response.Success(w, ins)
   156  }