public async Task <IResult> Handle(UpdateGroupCommand request, CancellationToken cancellationToken)
{
var group = await _groupRepository.GetById(request.Id, cancellationToken).ConfigureAwait(false);
if (group == null)
{
return(Result.Failure(ErrorCodes.NotFound));
}
if (group.OwnerId != _userIdAccesor.Id)
{
return(Result.Failure(ErrorCodes.Forbid));
}
if (await _groupRepository.Exists(group, cancellationToken).ConfigureAwait(false))
{
return(Result.Failure(ErrorCodes.Conflict));
}
group.Code = request.Input.Code;
group.Name = request.Input.Name;
await _groupRepository.Update(group, cancellationToken)
.ConfigureAwait(false);
_userCacheService.Remove(CacheRegion.Groups);
return(Result.Success());
}
public async Task <IResult> Handle(UpdateTransactionCommand request, CancellationToken cancellationToken)
{
var transaction = await _transactionRepository.GetById(request.Id, cancellationToken)
.ConfigureAwait(false);
if (transaction == null)
{
return(Result.Failure(ErrorCodes.NotFound));
}
if (transaction.OwnerId != _userIdAccesor.Id)
{
return(Result.Failure(ErrorCodes.Forbid));
}
transaction.AssetId = request.Input.AssetId;
transaction.Wallet = request.Input.Wallet;
transaction.Amount = request.Input.Amount;
transaction.CurrencyId = request.Input.CurrencyId;
transaction.Rate = request.Input.Rate;
transaction.Fee = request.Input.Fee;
transaction.FeeCurrencyId = request.Input.FeeCurrencyId;
await _transactionRepository.Update(transaction, cancellationToken)
.ConfigureAwait(false);
_userCacheService.Remove(CacheRegion.Transactions);
return(Result.Success());
}
public async Task <IResult> Handle(UpdateAssetCommand request, CancellationToken cancellationToken)
{
var asset = await _assetRepository.GetById(request.Id, cancellationToken)
.ConfigureAwait(false);
if (asset == null)
{
return(Result.Failure(ErrorCodes.NotFound));
}
if (asset.OwnerId != _userIdAccesor.Id)
{
return(Result.Failure(ErrorCodes.Forbid));
}
if (await _assetRepository.Exists(asset, cancellationToken).ConfigureAwait(false))
{
return(Result.Failure(ErrorCodes.Conflict));
}
asset.Code = request.Input.Code;
asset.Name = request.Input.Name;
asset.Symbol = request.Input.Symbol;
asset.Icon = request.Input.Icon;
asset.GroupId = request.Input.GroupId;
asset.Order = request.Input.Order;
await _assetRepository.Update(asset, cancellationToken)
.ConfigureAwait(false);
_userCacheService.Remove(CacheRegion.Assets);
return(Result.Success());
}
public async Task <IResult> Handle(UpdateUserCurrencyCommand request, CancellationToken cancellationToken)
{
var currency = await _currencyRepository.GetById(request.Input.CurrencyId, cancellationToken)
.ConfigureAwait(false);
if (currency == null)
{
return(Result.Failure(ErrorCodes.NotFound));
}
var user = await _userRepository.GetMe(cancellationToken)
.ConfigureAwait(false);
if (user == null)
{
return(Result.Failure(ErrorCodes.NotFound));
}
var settings = user.GetSettings() ?? new UserSettings();
settings.PrefferedCurrency = request.Input.CurrencyId;
user.Settings = settings.ToString();
await _userRepository.Update(user, cancellationToken)
.ConfigureAwait(false);
_userCacheService.Remove(CacheRegion.Users);
return(Result.Success());
}
public async Task <IResult <AssetModel> > Handle(CreateAssetCommand request, CancellationToken cancellationToken)
{
var asset = new Asset
{
Code = request.Input.Code,
Name = request.Input.Name,
GroupId = request.Input.GroupId,
Order = request.Input.Order,
Icon = request.Input.Icon,
Symbol = request.Input.Symbol,
CreatedAt = DateTime.UtcNow,
OwnerId = _userIdAccesor.Id
};
if (await _assetRepository.Exists(asset, cancellationToken).ConfigureAwait(false))
{
return(Result.Failure <AssetModel>(ErrorCodes.Forbid));
}
asset = await _assetRepository.Add(asset, cancellationToken)
.ConfigureAwait(false);
_userCacheService.Remove(CacheRegion.Assets);
return(_mapper.Map <Asset, AssetModel>(asset).AsResult());
}
public async Task <IResult <TransactionModel> > Handle(CreateTransactionCommand request, CancellationToken cancellationToken)
{
var transaction = new Transaction
{
AssetId = request.Input.AssetId,
Wallet = request.Input.Wallet,
CreatedAt = request.Input.CreatedAt,
Amount = request.Input.Amount,
CurrencyId = request.Input.CurrencyId,
Rate = request.Input.Rate,
Fee = request.Input.Fee,
FeeCurrencyId = request.Input.FeeCurrencyId,
OwnerId = _userIdAccesor.Id
};
transaction = await _transactionRepository.Add(transaction, cancellationToken)
.ConfigureAwait(false);
var currencies = await _currencyRepository.GetAll()
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
var assets = await _assetRepository.GetAll()
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
var groups = await _groupRepository.GetAll()
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
var result = _mapper.Map <Transaction, TransactionModel>(transaction);
if (currencies.Found(request.Input.CurrencyId, out var currency))
{
result.Currency = _mapper.Map <Currency, CurrencyModel>(currency);
}
if (assets.Found(request.Input.AssetId, out var asset))
{
result.Asset = _mapper.Map <Asset, AssetModel>(asset);
if (groups.Found(asset.GroupId, out var group))
{
result.Asset.Group = _mapper.Map <Group, GroupModel>(group);
}
}
if (request.Input.FeeCurrencyId != null && currencies.Found(request.Input.FeeCurrencyId.Value, out var feeCurrency))
{
result.FeeCurrency = _mapper.Map <Currency, CurrencyModel>(feeCurrency);
}
_userCacheService.Remove(CacheRegion.Transactions);
return(result.AsResult());
}
public async Task <TResponse <bool> > Delete(int userId,
int id,
int permissionId)
{
try
{
var checkValid = await CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canDelete = await CanDelete(id);
if (canDelete.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_DELETE,
new
{
Id = id,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
//TODO: xoa file avatar
#region Update redis cache
await _userCacheService.Remove(id);
#endregion
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canDelete.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <IResult> Handle(DeleteTransactionCommand request, CancellationToken cancellationToken)
{
var transaction = await _transactionRepository.GetById(request.Id, cancellationToken)
.ConfigureAwait(false);
if (transaction == null)
{
return(Result.Failure(ErrorCodes.NotFound));
}
if (transaction.OwnerId != _userIdAccesor.Id)
{
return(Result.Failure(ErrorCodes.Forbid));
}
await _transactionRepository.Delete(transaction.Id, cancellationToken)
.ConfigureAwait(false);
_userCacheService.Remove(CacheRegion.Transactions);
return(Result.Success());
}
public async Task <IResult <GroupModel> > Handle(CreateGroupCommand request, CancellationToken cancellationToken)
{
var group = new Group
{
Code = request.Input.Code,
Name = request.Input.Name,
CreatedAt = DateTime.UtcNow,
OwnerId = _userIdAccesor.Id
};
if (await _groupRepository.Exists(group, cancellationToken).ConfigureAwait(false))
{
return(Result.Failure <GroupModel>(ErrorCodes.Forbid));
}
group = await _groupRepository.Add(group, cancellationToken)
.ConfigureAwait(false);
_userCacheService.Remove(CacheRegion.Groups);
return(_mapper.Map <Group, GroupModel>(group).AsResult());
}
public UserModule(IUserService userService, IErrorService error, IPasswordService passwordService, IUserCacheService userCacheService) : base("/user")
{
Post["/create"] = _ =>
{
if (Params.AreMissing("UserName", "Email"))
{
return(error.MissingParameters(Response));
}
if (userService.GetUserByName(Params.UserName) != null)
{
return(error.UserNameTaken(Response));
}
if (!Params.Email.IsEmail())
{
return(error.InvalidParameters(Response));
}
var password = userService.CreateUser(Params.UserName, Params.Email);
return((string.IsNullOrWhiteSpace(password)) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password }));
};
Post["/validate"] = _ =>
{
if (Params.AreMissing("UserName", "Password"))
{
return(error.MissingParameters(Response));
}
var user = userService.GetUserByName(Params.UserName);
if (user == null || !passwordService.IsPasswordValid(user, Params.Password))
{
return(error.NoUserForCredentials(Response));
}
var key = userCacheService.Add(user);
return((key == null) ? error.InvalidParameters(Response) : Response.AsJson(new { ThumbKey = key }));
};
Post["/get"] = _ =>
{
if (Params.AreMissing("ThumbKey"))
{
return(error.MissingParameters(Response));
}
if (!Params.ThumbKey.IsGuid())
{
return(error.InvalidParameters(Response));
}
var user = userCacheService.GetUser(Params.ThumbKey);
return((user == null) ? error.NoUserForThumbkey(Response) : Response.AsJson(new { User = new { Id = user.Id, UserName = user.UserName, Email = user.Email } }));
};
Post["/validate/thumbkey"] = _ =>
{
if (Params.AreMissing("ThumbKey"))
{
return(error.MissingParameters(Response));
}
if (!Params.ThumbKey.IsGuid())
{
return(error.InvalidParameters(Response));
}
var isValid = userCacheService.Validate(Params.ThumbKey);
return(!isValid?error.NoUserForThumbkey(Response) : HttpStatusCode.OK);
};
Post["/validate/name"] = _ =>
{
if (Params.AreMissing("UserName"))
{
return(error.MissingParameters(Response));
}
var isValid = userService.GetUserByName(Params.UserName) == null;
return(!isValid?error.UserNameTaken(Response) : HttpStatusCode.OK);
};
Post["/reset/password"] = _ =>
{
if (Params.AreMissing("UserName", "Password"))
{
return(error.MissingParameters(Response));
}
var user = userService.GetUserByName(Params.UserName);
if (user == null || !passwordService.IsPasswordValid(user, Params.Password))
{
return(error.NoUserForCredentials(Response));
}
var password = userService.ResetPassword(user);
return((password == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password }));
};
Post["/forgot-password/request"] = _ =>
{
if (Params.AreMissing("UserName", "Email"))
{
return(error.MissingParameters(Response));
}
if (!Params.Email.IsEmail())
{
return(error.InvalidParameters(Response));
}
var user = userService.GetUserByName(Params.UserName);
if (user == null)
{
return(error.NoUserForCredentials(Response));
}
if (user.Email != Params.Email)
{
return(error.NoUserForEmail(Response));
}
var token = userService.ForgotPasswordRequest(user);
return((token == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Token = token }));
};
Post["/forgot-password/reset"] = _ =>
{
if (Params.AreMissing("UserName", "Token"))
{
return(error.MissingParameters(Response));
}
if (!Params.Token.IsGuid())
{
return(error.InvalidParameters(Response));
}
var user = userService.GetUserByName(Params.UserName);
if (user == null || !passwordService.IsForgotPasswordTokenValid(user, Params.Token))
{
return(error.InvalidForgotPasswordToken(Response));
}
var password = userService.ForgotPasswordReset(user);
return((password == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password }));
};
Post["/logout"] = _ =>
{
if (Params.AreMissing("ThumbKey"))
{
return(error.MissingParameters(Response));
}
if (!Params.ThumbKey.IsGuid())
{
return(error.InvalidParameters(Response));
}
var success = userCacheService.Remove(Params.ThumbKey);
return(!success?error.NoUserForThumbkey(Response) : HttpStatusCode.OK);
};
}
public UserModule(IUserService userService, IErrorService error, IPasswordService passwordService, IUserCacheService userCacheService)
: base("/user")
{
Post["/create"] = _ =>
{
if (Params.AreMissing("UserName", "Email")) return error.MissingParameters(Response);
if (userService.GetUserByName(Params.UserName)!=null) return error.UserNameTaken(Response);
if (!Params.Email.IsEmail()) return error.InvalidParameters(Response);
var password = userService.CreateUser(Params.UserName, Params.Email);
return (string.IsNullOrWhiteSpace(password)) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password });
};
Post["/validate"] = _ =>
{
if (Params.AreMissing("UserName", "Password")) return error.MissingParameters(Response);
var user = userService.GetUserByName(Params.UserName);
if (user == null || !passwordService.IsPasswordValid(user, Params.Password)) return error.NoUserForCredentials(Response);
var key = userCacheService.Add(user);
return (key == null) ? error.InvalidParameters(Response) : Response.AsJson(new { ThumbKey = key });
};
Post["/get"] = _ =>
{
if (Params.AreMissing("ThumbKey")) return error.MissingParameters(Response);
if (!Params.ThumbKey.IsGuid()) return error.InvalidParameters(Response);
var user = userCacheService.GetUser(Params.ThumbKey);
return (user == null) ? error.NoUserForThumbkey(Response) : Response.AsJson(new { User = new { Id = user.Id, UserName = user.UserName, Email = user.Email } });
};
Post["/validate/thumbkey"] = _ =>
{
if (Params.AreMissing("ThumbKey")) return error.MissingParameters(Response);
if (!Params.ThumbKey.IsGuid()) return error.InvalidParameters(Response);
var isValid = userCacheService.Validate(Params.ThumbKey);
return !isValid ? error.NoUserForThumbkey(Response) : HttpStatusCode.OK;
};
Post["/validate/name"] = _ =>
{
if (Params.AreMissing("UserName")) return error.MissingParameters(Response);
var isValid = userService.GetUserByName(Params.UserName)==null;
return !isValid ? error.UserNameTaken(Response) : HttpStatusCode.OK;
};
Post["/reset/password"] = _ =>
{
if (Params.AreMissing("UserName", "Password")) return error.MissingParameters(Response);
var user = userService.GetUserByName(Params.UserName);
if (user == null || !passwordService.IsPasswordValid(user, Params.Password)) return error.NoUserForCredentials(Response);
var password = userService.ResetPassword(user);
return (password == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password });
};
Post["/forgot-password/request"] = _ =>
{
if (Params.AreMissing("UserName", "Email")) return error.MissingParameters(Response);
if (!Params.Email.IsEmail()) return error.InvalidParameters(Response);
var user = userService.GetUserByName(Params.UserName);
if (user == null) return error.NoUserForCredentials(Response);
if (user.Email != Params.Email) return error.NoUserForEmail(Response);
var token = userService.ForgotPasswordRequest(user);
return (token == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Token = token });
};
Post["/forgot-password/reset"] = _ =>
{
if (Params.AreMissing("UserName", "Token")) return error.MissingParameters(Response);
if (!Params.Token.IsGuid()) return error.InvalidParameters(Response);
var user = userService.GetUserByName(Params.UserName);
if (user == null || !passwordService.IsForgotPasswordTokenValid(user, Params.Token)) return error.InvalidForgotPasswordToken(Response);
var password = userService.ForgotPasswordReset(user);
return (password == null) ? error.InvalidParameters(Response) : Response.AsJson(new { Password = password });
};
Post["/logout"] = _ =>
{
if (Params.AreMissing("ThumbKey")) return error.MissingParameters(Response);
if (!Params.ThumbKey.IsGuid()) return error.InvalidParameters(Response);
var success = userCacheService.Remove(Params.ThumbKey);
return !success ? error.NoUserForThumbkey(Response) : HttpStatusCode.OK;
};
}
