public async Task <IResponseOutput> AddAsync(UserAddInput input)
{
if (input.Password.IsNull())
{
input.Password = "******";
}
input.Password = MD5Encrypt.Encrypt32(input.Password);
var entity = _mapper.Map <UserEntity>(input);
var user = await _userRepository.InsertAsync(entity);
if (!(user?.Id > 0))
{
return(ResponseOutput.NotOk());
}
if (input.RoleIds != null && input.RoleIds.Any())
{
var roles = input.RoleIds.Select(d => new UserRoleEntity(user.Id, d));
await _userRoleRepository.InsertAsync(roles);
}
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> AddAsync(TenantAddInput input)
{
var entity = Mapper.Map <TenantEntity>(input);
var tenant = await _tenantRepository.InsertAsync(entity);
var tenantId = tenant.Id;
//添加角色
var role = new RoleEntity {
TenantId = tenantId, Code = "plat_admin", Name = "平台管理员", Enabled = true
};
await _roleRepository.InsertAsync(role);
//添加用户
var pwd = MD5Encrypt.Encrypt32("111111");
var user = new UserEntity {
TenantId = tenantId, UserName = input.Phone, NickName = input.RealName, Password = pwd, Status = 0
};
await _userRepository.InsertAsync(user);
//添加用户角色
var userRole = new UserRoleEntity()
{
TenantId = tenantId, UserId = user.Id, RoleId = role.Id
};
await _userRoleRepository.InsertAsync(userRole);
//更新租户用户
tenant.UserId = user.Id;
await _tenantRepository.UpdateAsync(tenant);
return(ResponseOutput.Ok());
}
public async Task <IResponseEntity> CreateAsync(UserAddRequest req)
{
var item = _mapper.Map <SysUserEntity>(req);
item.Password = MD5Encrypt.Encrypt32(item.Password);
var result = await _sysUserRepository.InsertAsync(item);
return(ResponseEntity.Result(result != null && result?.Id != ""));
}
public async Task <IResponseOutput> AddAsync(UserSaveInput input)
{
if (input.Password.IsNull())
{
input.Password = "******";
}
input.Password = MD5Encrypt.Encrypt32(input.Password);
var entity = _mapper.Map <UserEntity>(input);
entity.CreatedTime = DateTime.Now;
await _userRepo.InsertAsync(entity);
return(ResponseOutput.Ok());
}
public async Task <IResultModel> AddAsync(UserEntity input)
{
if (input.Password.IsNull())
{
input.Password = "******";
}
input.Password = MD5Encrypt.Encrypt32(input.Password);
var entity = _mapper.Map <UserEntity>(input);
entity.IsDeleted = false;
entity.ModifiedTime = entity.CreatedTime = DateTime.UtcNow;
entity.CreatedUserId = entity.ModifiedUserId = _user.Id;
entity.CreatedUserName = entity.ModifiedUserName = _user.Name;
try
{
_userRepository.BeginTrans();
var _id = await _userRepository.InsertAsync(entity);
if (!(_id > 0))
{
return(ResultModel.Failed());
}
UserRoleEntity _userRoleEntity;
if (input.RoleIds != null && input.RoleIds.Any())
{
foreach (var _ro in input.RoleIds)
{
_userRoleEntity = new UserRoleEntity
{
RoleId = _ro,
UserId = _id,
CreatedTime = DateTime.UtcNow,
CreatedUserId = _user.Id,
CreatedUserName = _user.Name
};
await _userRepository.Transaction.Connection.InsertAsync <UserRoleEntity>(_userRoleEntity, _userRepository.Transaction);
}
}
_userRepository.Commit();
}
catch (Exception ex)
{
_userRepository.Rollback();
}
return(ResultModel.Success());
}
public async Task <IResponseEntity> LoginAsync(AuthLoginRequest req)
{
var password = MD5Encrypt.Encrypt32(req.Password);
SysUserEntity user = new SysUserEntity();
using (_userRepository.DataFilter.Disable("Group"))
{
user = await _userRepository.GetAsync(a => a.UserName == req.UserName && a.Password == password);
}
if (user?.Id == "")
{
return(ResponseEntity.Error("账号或密码错误!"));
}
var res = await getUserItem(user);
return(ResponseEntity.Ok(res));
}
/// <summary>
/// 修改当前登录人的密码
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public async Task <IResponseEntity> ChangePasswordAsync(ChangePasswordRequest req)
{
var oldPassword = MD5Encrypt.Encrypt32(req.OldPassword);
var item = _sysUserRepository.Where(a => a.Id == _authUser.Id && a.Password == oldPassword).First();
if (item == null)
{
return(ResponseEntity.Error("旧密码错误，请输入正确的旧密码"));
}
if (req.NewPassword != req.ConfirmPassword)
{
return(ResponseEntity.Error("两次密码不一致，请重新输入"));
}
var newPassword = MD5Encrypt.Encrypt32(req.NewPassword);
item.Password = newPassword;
await _sysUserRepository.UpdateAsync(item);
return(ResponseEntity.Ok("更新成功"));
}
/// <summary>
/// 验证登录信息
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
{
var user = await _userRepository.Select.Where(a => a.UserName == context.UserName).ToOneAsync();
if (user == null)
{
context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "账号输入有误!");
return;
}
var password = MD5Encrypt.Encrypt32(context.Password);
if (user.Password != password)
{
context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "密码输入有误!");
return;
}
context.Result = new GrantValidationResult(user.Id.ToString(), OidcConstants.AuthenticationMethods.Password);
}
public async Task<IResponseOutput> ChangePasswordAsync(UserChangePasswordInput input)
{
if (input.ConfirmPassword != input.NewPassword)
{
return ResponseOutput.NotOk("新密码和确认密码不一致！");
}
var entity = await _userRepository.GetAsync(input.Id);
var oldPassword = MD5Encrypt.Encrypt32(input.OldPassword);
if (oldPassword != entity.Password)
{
return ResponseOutput.NotOk("旧密码不正确！");
}
input.Password = MD5Encrypt.Encrypt32(input.NewPassword);
entity = _mapper.Map(input, entity);
var result = (await _userRepository.UpdateAsync(entity)) > 0;
return ResponseOutput.Result(result);
}
/// <summary>
/// 更新指定用户的密码
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public async Task <IResponseEntity> UserChangePasswordAsync(UserChangePasswordRequest req)
{
if (req == null || req?.Id == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
if (req.Password != req.ConfirmPassword)
{
return(ResponseEntity.Error("两次密码不一致，请重新输入"));
}
var password = MD5Encrypt.Encrypt32(req.Password);
var item = new SysUserEntity()
{
Id = req.Id, Revision = req.Revision
};
_sysUserRepository.Attach(item); //此时快照 item
item.Password = password;
await _sysUserRepository.UpdateAsync(item); //对比快照时的变化
return(ResponseEntity.Ok("更新成功"));
}
public async Task <IResponseOutput> LoginAsync(AuthLoginInput input)
{
#region 验证码校验
var verifyCodeKey = string.Format(CacheKey.VerifyCodeKey, input.VerifyCodeKey);
var exists = await _cache.ExistsAsync(verifyCodeKey);
if (exists)
{
var verifyCode = await _cache.GetAsync(verifyCodeKey);
if (string.IsNullOrEmpty(verifyCode))
{
return(ResponseOutput.NotOk("验证码已过期！", 1));
}
if (verifyCode.ToLower() != input.VerifyCode.ToLower())
{
return(ResponseOutput.NotOk("验证码输入有误！", 2));
}
await _cache.DelAsync(verifyCodeKey);
}
else
{
return(ResponseOutput.NotOk("验证码已过期！", 1));
}
#endregion
var user = (await _userRepository.GetAsync(a => a.UserName == input.UserName));
if (!(user?.Id > 0))
{
return(ResponseOutput.NotOk("账号输入有误!", 3));
}
#region 解密
if (input.PasswordKey.NotNull())
{
var passwordEncryptKey = string.Format(CacheKey.PassWordEncryptKey, input.PasswordKey);
var existsPasswordKey = await _cache.ExistsAsync(passwordEncryptKey);
if (existsPasswordKey)
{
var secretKey = await _cache.GetAsync(passwordEncryptKey);
if (secretKey.IsNull())
{
return(ResponseOutput.NotOk("解密失败！", 1));
}
input.Password = DesEncrypt.Decrypt(input.Password, secretKey);
await _cache.DelAsync(passwordEncryptKey);
}
else
{
return(ResponseOutput.NotOk("解密失败！", 1));
}
}
#endregion
var password = MD5Encrypt.Encrypt32(input.Password);
if (user.Password != password)
{
return(ResponseOutput.NotOk("密码输入有误！", 4));
}
var authLoginOutput = _mapper.Map <AuthLoginOutput>(user);
return(ResponseOutput.Ok(authLoginOutput));
}
public async Task <IResultModel> LoginAsync(AuthLoginInput input)
{
#region 验证码校验
//if (_appConfig.VarifyCode.Enable)
//{
// var verifyCodeKey = string.Format(CacheKey.VerifyCodeKey, input.VerifyCodeKey);
// var exists = await _cache.ExistsAsync(verifyCodeKey);
// if (exists)
// {
// var verifyCode = await _cache.GetAsync(verifyCodeKey);
// if (string.IsNullOrEmpty(verifyCode))
// {
// return ResponseOutput.NotOk("验证码已过期！", 1);
// }
// if (verifyCode.ToLower() != input.VerifyCode.ToLower())
// {
// return ResponseOutput.NotOk("验证码输入有误！", 2);
// }
// await _cache.DelAsync(verifyCodeKey);
// }
// else
// {
// return ResponseOutput.NotOk("验证码已过期！", 1);
// }
//}
#endregion
string conditions = "where UserName=@UserName ";
var user = await _userRepository.GetAsync(conditions, new { input.UserName });
if (!(user?.Id > 0))
{
return(ResultModel.Failed("账号输入有误!", 3));
}
#region 解密
//if (input.PasswordKey.NotNull())
//{
// var passwordEncryptKey = string.Format(CacheKey.PassWordEncryptKey, input.PasswordKey);
// var existsPasswordKey = await _cache.ExistsAsync(passwordEncryptKey);
// if (existsPasswordKey)
// {
// var secretKey = await _cache.GetAsync(passwordEncryptKey);
// if (secretKey.IsNull())
// {
// return ResponseOutput.NotOk("解密失败！", 1);
// }
// input.Password = DesEncrypt.Decrypt(input.Password, secretKey);
// await _cache.DelAsync(passwordEncryptKey);
// }
// else
// {
// return ResponseOutput.NotOk("解密失败！", 1);
// }
//}
#endregion
var password = MD5Encrypt.Encrypt32(input.Password);
if (user.Password != password)
{
return(ResultModel.Failed("密码输入有误！", 4));
}
var authLoginOutput = _mapper.Map <AuthLoginOutput>(user);
//await _cache.SetAsync(CacheKey.UserAuthLogin, authLoginOutput, TimeSpan.FromMinutes(5));
return(ResultModel.Success(authLoginOutput));
}
public async Task <IResponseOutput> Login(LoginInput input)
{
if (!ModelState.IsValid)
{
return(ResponseOutput.NotOk(ModelState.Values.First().Errors[0].ErrorMessage));
}
var sw = new Stopwatch();
sw.Start();
var context = await _interaction.GetAuthorizationContextAsync(input.ReturnUrl);
var user = await _userRepository.Select.Where(a => a.UserName == input.UserName)
.ToOneAsync(a => new { a.Id, a.Password, a.NickName });
if (user == null)
{
return(ResponseOutput.NotOk("", 1));
}
var password = MD5Encrypt.Encrypt32(input.Password);
if (user.Password != password)
{
return(ResponseOutput.NotOk("", 2));
}
AuthenticationProperties props = null;
if (input.RememberLogin)
{
props = new AuthenticationProperties
{
IsPersistent = true,
ExpiresUtc = DateTimeOffset.UtcNow.Add(TimeSpan.FromDays(1))
};
}
;
var identityServerUser = new IdentityServerUser(user.Id.ToString())
{
DisplayName = input.UserName
};
await HttpContext.SignInAsync(identityServerUser, props);
sw.Stop();
//写登录日志
var loginLogEntity = new LoginLogEntity()
{
CreatedUserId = user.Id,
NickName = user.NickName,
CreatedUserName = input.UserName,
ElapsedMilliseconds = sw.ElapsedMilliseconds,
Status = true
};
await AddLoginLog(loginLogEntity);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> LoginAsync(AuthLoginParam param)
{
#region 验证码校验
if (Configs.AppSettings.VarifyCode.Enable)
{
var verifyCodeKey = string.Format(CacheKey.VerifyCodeKey, param.VerifyCodeKey);
var exists = await BaseCache.ExistsAsync(verifyCodeKey);
if (exists)
{
var verifyCode = await BaseCache.GetAsync(verifyCodeKey);
if (string.IsNullOrEmpty(verifyCode))
{
return(ResponseOutput.NotOk("验证码已过期！"));
}
if (verifyCode.ToLower() != param.VerifyCode.ToLower())
{
return(ResponseOutput.NotOk("验证码输入有误！", 2));
}
await BaseCache.DelAsync(verifyCodeKey);
}
else
{
return(ResponseOutput.NotOk("验证码已过期！", 1));
}
}
#endregion
var user = await _userRepo.FindAsync(a => a.UserName == param.UserName);
if (string.IsNullOrWhiteSpace(user?.Id))
{
return(ResponseOutput.NotOk("账号输入有误!", 3));
}
#region 解密
if (param.PasswordKey.NotNull())
{
var passwordEncryptKey = string.Format(CacheKey.PassWordEncryptKey, param.PasswordKey);
var existsPasswordKey = await BaseCache.ExistsAsync(passwordEncryptKey);
if (existsPasswordKey)
{
var secretKey = await BaseCache.GetAsync(passwordEncryptKey);
if (secretKey.IsNull())
{
return(ResponseOutput.NotOk("解密失败！", 1));
}
param.Password = DesEncrypt.Decrypt(param.Password, secretKey);
await BaseCache.DelAsync(passwordEncryptKey);
}
else
{
return(ResponseOutput.NotOk("解密失败！", 1));
}
}
#endregion
var password = MD5Encrypt.Encrypt32(param.Password);
if (user.Password != password)
{
return(ResponseOutput.NotOk("密码输入有误！", 4));
}
var authLoginOutput = ObjectMapper.Map <AuthLoginOutput>(user);//user.MapTo<UserEntity, AuthLoginOutput>();
return(ResponseOutput.Ok(authLoginOutput));
}
public async Task <IResponseOutput> Login(LoginInputModel input)
{
if (!ModelState.IsValid)
{
return(ResponseOutput.NotOk(ModelState.Values.First().Errors[0].ErrorMessage));
}
var sw = new Stopwatch();
sw.Start();
// check if we are in the context of an authorization request
var context = await _interaction.GetAuthorizationContextAsync(input.ReturnUrl);
var user = await _userRepository.Select.Where(a => a.UserName == input.UserName)
.ToOneAsync(a => new { a.Id, a.Password, a.NickName });
if (user == null)
{
return(ResponseOutput.NotOk("", 1));
}
var password = MD5Encrypt.Encrypt32(input.Password);
if (user.Password != password)
{
return(ResponseOutput.NotOk("", 2));
}
await _events.RaiseAsync(new UserLoginSuccessEvent(input.UserName, user.Id.ToString(), input.UserName, clientId : context?.ClientId));
// only set explicit expiration here if user chooses "remember me".
// otherwise we rely upon expiration configured in cookie middleware.
AuthenticationProperties props = null;
if (AccountOptions.AllowRememberLogin && input.RememberLogin)
{
props = new AuthenticationProperties
{
IsPersistent = true,
ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
};
}
;
// issue authentication cookie with subject ID and username
var isuser = new IdentityServerUser(user.Id.ToString())
{
DisplayName = input.UserName
};
await HttpContext.SignInAsync(isuser, props);
sw.Stop();
//写登录日志
var loginLogEntity = new LoginLogEntity()
{
CreatedUserId = user.Id,
NickName = user.NickName,
CreatedUserName = input.UserName,
ElapsedMilliseconds = sw.ElapsedMilliseconds,
Status = true
};
await AddLoginLog(loginLogEntity);
return(ResponseOutput.Ok());
/*
* if (context != null)
* {
* if (await _clientStore.IsPkceClientAsync(context.ClientId))
* {
* // if the client is PKCE then we assume it's native, so this change in how to
* // return the response is for better UX for the end user.
* return this.LoadingPage("Redirect", input.ReturnUrl);
* }
*
* // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
* return Redirect(input.ReturnUrl);
* }
*
* // request for a local page
* if (Url.IsLocalUrl(input.ReturnUrl))
* {
* return Redirect(input.ReturnUrl);
* }
* else if (string.IsNullOrEmpty(input.ReturnUrl))
* {
* return Redirect("~/");
* }
* else
* {
* // user might have clicked on a malicious link - should be logged
* throw new Exception("invalid return URL");
* }
*
* await _events.RaiseAsync(new UserLoginFailureEvent(input.UserName, "invalid credentials", clientId: context?.ClientId));
* ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
*/
}
public async Task <IResponseOutput> Login(LoginInput input)
{
if (!ModelState.IsValid)
{
return(ResponseOutput.NotOk(ModelState.Values.First().Errors[0].ErrorMessage));
}
if (input.Captcha == null)
{
return(ResponseOutput.NotOk("请完成安全验证！"));
}
//滑动验证
input.Captcha.DeleteCache = true;
using var client = new HttpClient();
var res = await client.GetAsync($"{_appSettings.Captcha.CheckUrl}?{ToParams(input.Captcha)}");
var content = await res.Content.ReadAsStringAsync();
var captchaResult = JsonConvert.DeserializeObject <ResultModel <string> >(content);
if (!captchaResult.Success)
{
return(ResponseOutput.NotOk("安全验证不通过，请重新登录！"));
}
var sw = new Stopwatch();
sw.Start();
var context = await _interaction.GetAuthorizationContextAsync(input.ReturnUrl);
var user = await _userRepository.Select.Where(a => a.UserName == input.UserName)
.ToOneAsync(a => new { a.Id, a.Password, a.NickName, a.TenantId });
if (user == null)
{
return(ResponseOutput.NotOk("", 1));
}
var password = MD5Encrypt.Encrypt32(input.Password);
if (user.Password != password)
{
return(ResponseOutput.NotOk("", 2));
}
AuthenticationProperties props = null;
if (input.RememberLogin)
{
props = new AuthenticationProperties
{
IsPersistent = true,
ExpiresUtc = DateTimeOffset.UtcNow.Add(TimeSpan.FromDays(1))
};
}
;
var identityServerUser = new IdentityServerUser(user.Id.ToString())
{
DisplayName = input.UserName
};
await HttpContext.SignInAsync(identityServerUser, props);
sw.Stop();
//写登录日志
var loginLogEntity = new LoginLogEntity()
{
Id = YitIdHelper.NextId(),
TenantId = user.TenantId,
CreatedUserId = user.Id,
NickName = user.NickName,
CreatedUserName = input.UserName,
ElapsedMilliseconds = sw.ElapsedMilliseconds,
Status = true
};
await AddLoginLog(loginLogEntity);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> LoginAsync(AuthLoginInput input)
{
#region 验证码校验
var verifyCodeKey = string.Format(CacheKey.VerifyCodeKey, input.VerifyCodeKey);
var exists = await _cache.ExistsAsync(verifyCodeKey);
if (exists)
{
var verifyCode = await _cache.GetAsync(verifyCodeKey);
if (string.IsNullOrEmpty(verifyCode))
{
return(ResponseOutput.NotOk("验证码已过期！", 1));
}
if (verifyCode.ToLower() != input.VerifyCode.ToLower())
{
return(ResponseOutput.NotOk("验证码输入有误！", 2));
}
await _cache.DelAsync(verifyCodeKey);
}
else
{
return(ResponseOutput.NotOk("验证码已过期！", 1));
}
#endregion
var user = (await _userRepository.Select.Where(a => a.UserName == input.UserName).ToOneAsync());
if (!(user?.Id > 0))
{
return(ResponseOutput.NotOk("账号输入有误!", 3));
}
#region 解密
if (input.PasswordKey.NotNull())
{
var passwordEncryptKey = string.Format(CacheKey.PassWordEncryptKey, input.PasswordKey);
var existsPasswordKey = await _cache.ExistsAsync(passwordEncryptKey);
if (existsPasswordKey)
{
var secretKey = await _cache.GetAsync(passwordEncryptKey);
if (passwordEncryptKey.IsNull())
{
return(ResponseOutput.NotOk("解密失败！", 1));
}
input.Password = DesEncrypt.Decrypt(input.Password, secretKey);
await _cache.DelAsync(passwordEncryptKey);
}
else
{
return(ResponseOutput.NotOk("解密失败！", 1));
}
}
#endregion
var password = MD5Encrypt.Encrypt32(input.Password);
if (user.Password != password)
{
return(ResponseOutput.NotOk("密码输入有误！", 4));
}
//生成token信息
var claims = new[]
{
new Claim(ClaimAttributes.UserId, user.Id.ToString()),
new Claim(ClaimAttributes.UserName, user.UserName),
new Claim(ClaimAttributes.UserRealName, user.Name)
};
var token = _userToken.Build(claims);
return(ResponseOutput.Ok(new
{
token
}));
}
public async Task <IResponseOutput> LoginAsync(AuthLoginInput input)
{
#region 验证码校验
if (_appConfig.VarifyCode.Enable)
{
var verifyCodeKey = string.Format(CacheKey.VerifyCodeKey, input.VerifyCodeKey);
var exists = await Cache.ExistsAsync(verifyCodeKey);
if (exists)
{
var verifyCode = await Cache.GetAsync(verifyCodeKey);
if (string.IsNullOrEmpty(verifyCode))
{
return(ResponseOutput.NotOk("验证码已过期！", 1));
}
if (verifyCode.ToLower() != input.VerifyCode.ToLower())
{
return(ResponseOutput.NotOk("验证码输入有误！", 2));
}
await Cache.DelAsync(verifyCodeKey);
}
else
{
return(ResponseOutput.NotOk("验证码已过期！", 1));
}
}
#endregion 验证码校验
UserEntity user = null;
user = await _userRepository.Select.DisableGlobalFilter("Tenant").Where(a => a.UserName == input.UserName).ToOneAsync();
//user = (await _userRepository.GetAsync(a => a.UserName == input.UserName));
if (!(user?.Id > 0))
{
return(ResponseOutput.NotOk("账号输入有误!", 3));
}
#region 解密
if (input.PasswordKey.NotNull())
{
var passwordEncryptKey = string.Format(CacheKey.PassWordEncryptKey, input.PasswordKey);
var existsPasswordKey = await Cache.ExistsAsync(passwordEncryptKey);
if (existsPasswordKey)
{
var secretKey = await Cache.GetAsync(passwordEncryptKey);
if (secretKey.IsNull())
{
return(ResponseOutput.NotOk("解密失败！", 1));
}
input.Password = DesEncrypt.Decrypt(input.Password, secretKey);
await Cache.DelAsync(passwordEncryptKey);
}
else
{
return(ResponseOutput.NotOk("解密失败！", 1));
}
}
#endregion 解密
var password = MD5Encrypt.Encrypt32(input.Password);
if (user.Password != password)
{
return(ResponseOutput.NotOk("密码输入有误！", 4));
}
var authLoginOutput = Mapper.Map <AuthLoginOutput>(user);
if (_appConfig.Tenant)
{
var tenant = await _tenantRepository.Select.DisableGlobalFilter("Tenant").WhereDynamic(user.TenantId).ToOneAsync(a => new { a.TenantType, a.DataIsolationType });
authLoginOutput.TenantType = tenant.TenantType;
authLoginOutput.DataIsolationType = tenant.DataIsolationType;
}
//登录清空用户缓存
await Cache.DelAsync(string.Format(CacheKey.UserInfo, user.Id));
return(ResponseOutput.Ok(authLoginOutput));
}
