public VarlikResult Save(UserDto userDto)
{
var result = new VarlikResult();
using (var ctx = new VarlikContext())
{
var isAdded = ctx.User.Any(l => !l.IsDeleted && l.Mail == userDto.Mail);
if (isAdded)
{
result.Status = ResultStatus.AlreadyAdded;
return(result);
}
var entity = userDto.ToEntity(userDto);
var persistent = ctx.User.Add(entity);
try
{
ctx.SaveChanges();
result.Success();
result.ObjectId = persistent.Id;
}
catch (Exception e)
{
Log.Error("Save", e);
}
}
return(result);
}
public VarlikResult <TokenUser> Decode(string token)
{
var result = new VarlikResult <TokenUser>();
try
{
IJsonSerializer serializer = new JsonNetSerializer();
IDateTimeProvider provider = new UtcDateTimeProvider();
IJwtValidator validator = new JwtValidator(serializer, provider);
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtDecoder decoder = new JwtDecoder(serializer, validator, urlEncoder);
var json = decoder.Decode(token, secret, verify: true);
var res = JsonConvert.DeserializeObject <TokenUser>(json);
/* if ((DateTime.Now -res.CreatedAt).Minutes >3 )
* {
* result.Status = ResultStatus.TokenTimedOut;
* return result;
* }*/
result.Data = res;
result.Success();
return(result);
}
catch (Exception e)
{
}
return(result);
}
public VarlikResult AddWalletAddress(UserWalletDto userWalletDto)
{
var result = new VarlikResult();
using (var ctx = new VarlikContext())
{
var isAdded = ctx.UserWallet.Any(l =>
l.IdUser == userWalletDto.IdUser && l.IdCoinType == userWalletDto.IdCoinType);
if (isAdded)
{
result.Status = ResultStatus.AlreadyAdded;
return(result);
}
var entity = userWalletDto.ToEntity(userWalletDto);
var persistent = ctx.UserWallet.Add(entity);
try
{
ctx.SaveChanges();
result.Success();
result.ObjectId = persistent.Id;
}
catch (Exception e)
{
Log.Error("AddWalletAddress", e);
}
}
return(result);
}
public VarlikResult Register(UserDto userDto)
{
if (userDto == null)
{
var preResult = new VarlikResult();
preResult.Status = ResultStatus.MissingRequiredParamater;
return(preResult);
}
var name = userDto.Name.Trim();
var firstCharOfName = name.Substring(0, 1);
var remainingOfName = name.Substring(1);
userDto.Name = firstCharOfName.ToUpper() + remainingOfName.ToLower();
var surname = userDto.Surname.Trim();
var firstCharOfSurname = surname.Substring(0, 1);
var remaingOfSurname = surname.Substring(1);
userDto.Surname = firstCharOfSurname.ToUpper() + remaingOfSurname.ToLower();
var result = _userOperation.Register(userDto);
if (result.IsSuccess)
{
MailManager mailManager = new MailManager();
mailManager.SendWelcome(userDto);
}
return(result);
}
private VarlikResult <string> CreateBucket()
{
var bucketProjectId = WebConfigurationManager.AppSettings["bucketProjectId"];
if (string.IsNullOrEmpty(bucketProjectId))
{
Log.Error("CreateBucket : Cannot Get Bucket Project Id");
return(new VarlikResult <string>());
}
var result = new VarlikResult <string>();
string projectId = bucketProjectId;
try
{
StorageClient storageClient = StorageClient.Create();
string bucketName = projectId + "_files";
result.Data = bucketName;
result.Success();
storageClient.CreateBucket(projectId, bucketName);
}
catch (Google.GoogleApiException e)
{
if (e.Error.Code != 409)
{
result.Status = ResultStatus.UnknownError;
}
}
return(result);
}
public VarlikResult <string> ForgotPassword(string mail)
{
var result = new VarlikResult <string>();
using (var ctx = new VarlikContext())
{
var user = ctx.User.FirstOrDefault(l => l.Mail == mail && !l.IsDeleted);
if (user != null)
{
user.Password = Guid.NewGuid().ToString();
user.Password = VarlikHasher.Hash(user.Password);
try
{
ctx.SaveChanges();
result.Success();
result.Data = user.Password;
}
catch (Exception e)
{
Log.Error("ForgotPassword", e);
}
}
}
return(result);
}
public VarlikResult <TokenUser> Login(string mail, string password)
{
var result = new VarlikResult <TokenUser>();
using (var ctx = new VarlikContext())
{
password = VarlikHasher.Hash(password);
var entity = ctx.User
.FirstOrDefault(l => l.Mail == mail.ToLower() &&
l.Password == password &&
!l.IsDeleted);
if (entity == null)
{
result.Status = ResultStatus.LoginFailed;
return(result);
}
result.Data = new TokenUser()
{
Mail = mail,
Id = entity.Id,
CreatedAt = DateTime.Now,
IsApproved = entity.IsUserApproved,
Name = entity.Name,
Surname = entity.Surname
};
result.Success();
}
return(result);
}
public VarlikResult UpdatePassword(long idUser, UserUpdatePasswordDto userUpdatePasswordDto)
{
var result = new VarlikResult();
using (var ctx = new VarlikContext())
{
var user = ctx.User.FirstOrDefault(l => !l.IsDeleted && l.Id == idUser && l.Password == userUpdatePasswordDto.OldPassword);
if (user == null)
{
result.Status = ResultStatus.NoSuchObject;
return(result);
}
user.Password = VarlikHasher.Hash(user.Password);
user.Password = userUpdatePasswordDto.Password;
try
{
ctx.SaveChanges();
result.Success();
}
catch (Exception e)
{
Log.Error("UpdatePassword", e);
}
}
return(result);
}
public VarlikResult Save(UserTransactionLogDto userCoinTransactionLogDto)
{
if (userCoinTransactionLogDto == null)
{
var result = new VarlikResult();
result.Status = ResultStatus.MissingRequiredParamater;
return(result);
}
var saveResult = _userCoinTransactionLogOperation.Save(userCoinTransactionLogDto);
if (saveResult.IsSuccess)
{
var listR = GetLastTwoTransactionsByIdCoinType(userCoinTransactionLogDto.IdCoinType);
if (listR.IsSuccess && listR.Data.Count >= 2)
{
PriceDto priceDto = new PriceDto();
priceDto.IdCoinType = userCoinTransactionLogDto.IdCoinType;
priceDto.CoinUnitPrice = listR.Data[0].CoinUnitPrice;
if (listR.Data[0].CoinUnitPrice > listR.Data[1].CoinUnitPrice)
{
priceDto.IsIncreasing = true;
}
else
{
priceDto.IsIncreasing = false;
}
CoinPricePublisher coinPricePublisher = new CoinPricePublisher();
coinPricePublisher.PublishPrice(priceDto);
}
}
return(saveResult);
}
public VarlikResult IsValid()
{
var result = new VarlikResult();
var properties = GetType().GetProperties();
foreach (var propertyInfo in properties)
{
if (propertyInfo.Name == "IsExist" || propertyInfo.Name == "Select")
{
continue;
}
var attrs = propertyInfo.GetCustomAttributes(true);
var value = propertyInfo.GetValue(this);
var validAttr = attrs.OfType <ValidationAttribute>().FirstOrDefault(valid => !valid.IsValid(value));
if (validAttr == null)
{
continue;
}
result.Message = string.IsNullOrEmpty(validAttr.ErrorMessageResourceName) ?
(string.IsNullOrEmpty(validAttr.ErrorMessage) ?
validAttr.FormatErrorMessage(propertyInfo.Name) :
validAttr.ErrorMessage) :
validAttr.ErrorMessageResourceName;
result.Status = ResultStatus.InValidParamater;
return(result);
}
return(result.Success());
}
public VarlikResult <WalletResultDto> CreateNewAddress()
{
var result = new VarlikResult <WalletResultDto>();
var apiKeyManager = new ApiKeyManager();
var apiKeyR = apiKeyManager.GetApiKeyByIdCoinType(CoinTypeEnum.Ripple);
if (!apiKeyR.IsSuccess)
{
return(result);
}
var url = apiKeyR.Data.Url + "/createNewAddress/";
var request = (HttpWebRequest)WebRequest.Create(url);
request.Method = "GET";
request.ContentType = "application/x-www-form-urlencoded";
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
dynamic parsed = JObject.Parse(responseString);
result.Data = new WalletResultDto();
result.Data.Secret = parsed.wallet.secret;
result.Data.Address = parsed.wallet.address;
result.Success();
return(result);
}
public VarlikResult ApproveFromBankAdmin(long idMainOrder, string idTransactionState)
{
var result = new VarlikResult();
using (var ctx = new VarlikContext())
{
var data = ctx.MainOrderLog
.FirstOrDefault(l => l.Id == idMainOrder &&
l.IdTransactionState != TransactionStateEnum.Completed &&
l.IdTransactionType == TransactionTypeEnum.FromBank);
if (idTransactionState == TransactionStateEnum.Completed)
{
if (data != null)
{
data.IdTransactionState = TransactionStateEnum.Completed;
data.TransactionDate = DateTime.Now;
var order = ctx.UserCoinTransactionOrder
.FirstOrDefault(l => l.IdMainOrderLog == idMainOrder &&
l.IdTransactionState != TransactionStateEnum.Completed &&
l.IdTransactionType == TransactionTypeEnum.FromBank);
if (order != null)
{
ctx.UserCoinTransactionOrder.Remove(order);
}
//write tx log
var tx = new UserTransactionLog()
{
MoneyAmount = data.MoneyAmount,
IdTransactionState = TransactionStateEnum.Completed,
IdTransactionType = TransactionTypeEnum.FromBank,
TransactionDate = data.TransactionDate.Value,
IsSucces = true,
IdUser = data.IdUser,
IdMainOrderLog = idMainOrder
};
ctx.UserCoinTransactionLog.Add(tx);
try
{
ctx.SaveChanges();
result.Success();
}
catch (Exception e)
{
Log.Error("ApproveFromBankAdmin", e);
}
}
}
}
return(result);
}
public VarlikResult CancelTheOrder(long idMainOrder, long idUser)
{
var result = new VarlikResult();
using (var ctx = new VarlikContext())
{
var mainOrder = ctx.MainOrderLog
.FirstOrDefault(l => l.Id == idMainOrder && l.IdUser == idUser);
if (mainOrder == null)
{
result.Status = ResultStatus.NoSuchObject;
return(result);
}
if (mainOrder.IdTransactionState != TransactionStateEnum.Processing)
{
result.Status = ResultStatus.CannotBeCancelled;
return(result);
}
//sub orders
var subOrders = ctx.UserCoinTransactionOrder.Where(l => l.IdMainOrderLog == mainOrder.Id).ToList();
foreach (var item in subOrders)
{
item.IdTransactionState = TransactionStateEnum.CancelledByUser;
}
mainOrder.IdTransactionState = TransactionStateEnum.CancelledByUser;
try
{
ctx.SaveChanges();
result.Success();
//push
OrderPublisher orderPublisher = new OrderPublisher();
foreach (var item in subOrders)
{
orderPublisher.PublishOrder(item.IdCoinType, new TransactinOrderListDto()
{
CoinAmount = -1 * item.CoinAmount,
CoinUnitPrice = item.CoinUnitPrice,
IdTransactionType = item.IdTransactionType,
Total = -1 * item.CoinAmount * item.CoinUnitPrice
});
}
}
catch (Exception e)
{
}
}
return(result);
}
public VarlikResult Update(UserDto userDto)
{
if (userDto == null)
{
var preResult = new VarlikResult();
preResult.Status = ResultStatus.MissingRequiredParamater;
return(preResult);
}
userDto.Id = IdentityHelper.Instance.CurrentUserId;
return(_userOperation.Update(userDto));
}
public async Task <VarlikResult <AttachmentDto> > UploadFile(HttpPostedFile file)
{
var result = new VarlikResult <AttachmentDto>();
StorageClient storageClient = StorageClient.Create();
var createBucketResult = CreateBucket();
if (!createBucketResult.IsSuccess)
{
result.Status = createBucketResult.Status;
return(result);
}
var bucketName = createBucketResult.Data;
var fileName = IdentityHelper.Instance.TokenUser.Mail + "_" + Guid.NewGuid().ToString();
var fileAcl = PredefinedObjectAcl.BucketOwnerFullControl;
try
{
var fileObject = await storageClient.UploadObjectAsync(
bucket : bucketName,
objectName : fileName,
contentType : file.ContentType,
source : file.InputStream,
options : new UploadObjectOptions {
PredefinedAcl = fileAcl
}
);
AttachmentDto attachmentDto = new AttachmentDto();
attachmentDto.BucketName = bucketName;
attachmentDto.IdFileType = file.ContentType;
attachmentDto.Path = fileObject.MediaLink;
attachmentDto.FileName = file.FileName;
var attachmentSaveResult = await SaveAttachment(attachmentDto);
attachmentDto.Id = attachmentSaveResult.ObjectId;
result.Data = attachmentDto;
result.Data.Path = null;
result.Status = attachmentSaveResult.Status;
result.ObjectId = attachmentSaveResult.ObjectId;
return(result);
}
catch (Exception e)
{
}
return(result);
}
public VarlikResult <UserDto> GetUserByMail(string mail)
{
var result = new VarlikResult <UserDto>();
using (var ctx = new VarlikContext())
{
var fromEntity = new UserDto().FromEntity().Expand();
result.Data = ctx.User.AsExpandable().Where(l => l.Mail == mail && !l.IsDeleted).Select(fromEntity).FirstOrDefault();
result.Success();
}
return(result);
}
public VarlikResult ApproveToBankAdmin(long idMainOrder)
{
var userId = IdentityHelper.Instance.CurrentUserId;
if (userId > 0 && userId < 1001)
{
return(_mainOrderLogOperation.ApproveToBankAdmin(idMainOrder));
}
var result = new VarlikResult();
result.Status = ResultStatus.Unauthorized;
return(result);
}
public static void RedirectWithData(VarlikResult result)
{
var data = result != null?JsonConvert.SerializeObject(result) : string.Empty;
HttpContext.Current.Response.StatusCode = 401;
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.Buffer = true;
HttpContext.Current.Response.Charset = "utf-8";
HttpContext.Current.Response.ContentEncoding = System.Text.Encoding.UTF8;
HttpContext.Current.Response.ContentType = "application/json";
HttpContext.Current.Response.AddHeader("content-length", data.Length.ToString());
HttpContext.Current.Response.Write(data);
HttpContext.Current.Response.End();
}
public VarlikResult <decimal> GetTransferCommissionByIdCoinType(string idCoinType)
{
var result = new VarlikResult <decimal>();
using (var ctx = new VarlikContext())
{
result.Data = ctx.Commission
.Where(l => l.IdCoinType == idCoinType)
.Select(l => l.TransferFee)
.FirstOrDefault();
result.Success();
}
return(result);
}
public VarlikResult <string> Withdraw(string idCoinType,
string fromAddress,
string toAddress,
decimal amount,
string pin)
{
var result = new VarlikResult <string>();
try
{
var apiKeyManager = new ApiKeyManager();
var apiKeyR = apiKeyManager.GetApiKeyByIdCoinType(idCoinType);
if (!apiKeyR.IsSuccess)
{
return(result);
}
var url = apiKeyR.Data.Url + "/withdraw_from_addresses/";
url += "?api_key=" + apiKeyR.Data.Key;
url += "&amounts=" + amount;
url += "&from_addresses=" + fromAddress;
url += "&to_addresses=" + toAddress;
url += "&pin=" + pin;
var request = (HttpWebRequest)WebRequest.Create(url);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
dynamic parsed = JObject.Parse(responseString);
if (parsed.status == "success")
{
result.Data = parsed.data.txid;
result.Success();
}
else
{
result.Message = parsed.data.error_message;
}
}
catch (Exception e)
{
}
return(result);
}
public VarlikResult ApproveAdmin(long idMainOrder,
string idTransactionState,
bool commissionable,
decimal confirmableMoneyAmount = -1)
{
var userId = IdentityHelper.Instance.CurrentUserId;
if (userId > 0 && userId < 1001)
{
return(_adminOperation.ApproveAdmin(idMainOrder, idTransactionState, commissionable, confirmableMoneyAmount));
}
var result = new VarlikResult();
result.Status = ResultStatus.Unauthorized;
return(result);
}
public VarlikResult <List <CommisionDto> > GetAllCommission()
{
var result = new VarlikResult <List <CommisionDto> >();
using (var ctx = new VarlikContext())
{
var fromEntity = new CommisionDto().FromEntity().Expand();
result.Data = ctx.Commission
.AsExpandable()
.Select(fromEntity)
.ToList();
result.Success();
}
return(result);
}
public VarlikResult <List <TransactionStateDto> > GetAll()
{
var result = new VarlikResult <List <TransactionStateDto> >();
using (var ctx = new VarlikContext())
{
var fromEntity = new TransactionStateDto().FromEntity().Expand();
result.Data = ctx.TransactionStateEnum
.AsExpandable()
.Select(fromEntity)
.ToList();
result.Success();
}
return(result);
}
public VarlikResult <List <MainOrderLogDto> > GetAllOrder(long idUser)
{
var result = new VarlikResult <List <MainOrderLogDto> >();
using (var ctx = new VarlikContext())
{
var fromEntity = new MainOrderLogDto().FromEntity().Expand();
result.Data = ctx.MainOrderLog
.AsExpandable()
.Where(l => l.IdUser == idUser)
.Select(fromEntity)
.ToList();
result.Success();
}
return(result);
}
public VarlikResult <List <UserDto> > GetAllUserAdmin()
{
var result = new VarlikResult <List <UserDto> >();
using (var ctx = new VarlikContext())
{
var fromEntity = new UserDto().FromEntity().Expand();
result.Data = ctx.User
.AsExpandable()
.OrderByDescending(l => l.CreatedAt)
.Select(fromEntity)
.ToList();
result.Success();
}
return(result);
}
public VarlikResult <string> Encode(TokenUser tokenUser)
{
var result = new VarlikResult <string>();
IJwtAlgorithm algorithm = new HMACSHA256Algorithm();
IJsonSerializer serializer = new JsonNetSerializer();
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtEncoder encoder = new JwtEncoder(algorithm, serializer, urlEncoder);
var token = encoder.Encode(tokenUser, secret);
result.Data = token;
result.Success();
return(result);
}
public VarlikResult <List <MainOrderLogDto> > GetAllRealCoinOrderAdmin(int limit, int offset)
{
if (limit > 1000 || limit == 0)
{
limit = 1000;
}
var userId = IdentityHelper.Instance.CurrentUserId;
if (userId > 0 && userId < 1001)
{
return(_mainOrderLogOperation.GetAllRealCoinOrderAdmin(limit, offset));
}
var result = new VarlikResult <List <MainOrderLogDto> >();
result.Status = ResultStatus.Unauthorized;
return(result);
}
public VarlikResult <CommisionDto> GetCommission(string idCoinType, decimal transactionVolume)
{
var result = new VarlikResult <CommisionDto>();
using (var ctx = new VarlikContext())
{
var fromEntity = new CommisionDto().FromEntity().Expand();
result.Data = ctx.Commission
.AsExpandable()
.Where(l => l.IdCoinType == idCoinType && l.TransactionVolume <= (decimal)transactionVolume)
.OrderByDescending(l => l.TransactionVolume)
.Select(fromEntity)
.OrderByDescending(l => l.TransactionVolume)
.FirstOrDefault();
result.Success();
}
return(result);
}
public VarlikResult <ApiKeyDto> GetApiKeyByIdCoinType(string idCoinType)
{
var result = new VarlikResult <ApiKeyDto>();
using (var ctx = new VarlikContext())
{
var fromEntity = new ApiKeyDto().FromEntity().Expand();
result.Data = ctx.ApiKey
.AsExpandable()
.Where(l => l.IdCoinType == idCoinType)
.Select(fromEntity)
.FirstOrDefault();
result.Success();
}
return(result);
}
public VarlikResult Register(UserDto userDto)
{
var result = new VarlikResult();
using (var ctx = new VarlikContext())
{
result = userDto.IsValid();
if (!result.IsSuccess)
{
return(result);
}
var alreadyAdded = ctx.User.Any(l => l.Mail == userDto.Mail && !l.IsDeleted);
if (alreadyAdded)
{
result.Status = ResultStatus.AlreadyAdded;
return(result);
}
userDto.Password = VarlikHasher.Hash(userDto.Password);
User user = new User()
{
Mail = userDto.Mail.ToLower(),
Password = userDto.Password,
Name = userDto.Name,
Surname = userDto.Surname,
Phone = userDto.Phone,
IsContractApproved = true
};
ctx.User.Add(user);
try
{
ctx.SaveChanges();
result.Success();
}
catch (Exception e)
{
Log.Error("Register", e);
}
}
return(result);
}
