public Price ConvertPrice(double priceValue, CurrencyRecord currencyFrom, CurrencyRecord currencyTo)
{
if (currencyFrom == currencyTo)
{
return(new Price
{
Value = priceValue,
Currency = currencyFrom
});
}
var currencyExchange = CurrencyExchanges
.First(e => e.CurrencyFrom == currencyFrom &&
e.CurrencyTo == currencyTo);
var exchangeRate = IsCurrentUserSeller ? currencyExchange.RateForSeller : currencyExchange.RateForBuyer;
var convertedPrice = new Price
{
Value = priceValue * exchangeRate,
Currency = CurrentUserCurrency
};
return(convertedPrice);
}
public async Task CurrencyOperation_AddOrDeleteCurrency_VerifyDeleteOrReturnBadRequestForAdding(CurrencyManipulationOperation cmo)
{
var fakeCurrency = new CurrencyRecord {
Id = 1, Name = "FAKE"
};
var userServiceMock = new Mock <IUserService>();
userServiceMock
.Setup(x => x.FindCurrencyAsync(It.IsAny <string>()))
.ReturnsAsync(fakeCurrency);
var adminController = new AdminController(userServiceMock.Object, _adminServiceMock.Object, _dbMock.Object);
//act
var result = await adminController.CurrencyOperation(cmo, fakeCurrency.Name);
//assert
if (cmo == CurrencyManipulationOperation.Add)
{
Assert.IsType <BadRequestObjectResult>(result);
}
else
{
Assert.IsType <OkObjectResult>(result);
_adminServiceMock.Verify(x => x.DeleteCurrency(It.IsAny <CurrencyRecord>()));
_dbMock.Verify(x => x.SaveChangesAsync(It.IsAny <CancellationToken>()));
}
}
public void GenerateTagList()
{
string sql = "select * from Currency where ID > 0 order by NAME";
SqlConnection cnn = new SqlConnection(_SQLConnectionString);
SqlCommand cmdGam = new SqlCommand(sql, cnn);
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter(cmdGam);
da.Fill(ds);
TaglistBox.Items.Clear();
tagList.Clear();
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
DataRow MyReader = ds.Tables[0].Rows[i];
TaglistBox.Items.Add(MyReader["NAME"].ToString());
var tag = new CurrencyRecord();
tag.ID = Convert.ToInt16(MyReader["ID"].ToString());
tag.NAME = MyReader["NAME"].ToString();
tag.TITLE = MyReader["TITLE"].ToString();
tag.RSSLINK = MyReader["RSSLINK"].ToString();
tagList.Add(tag);
}
if (tagList.Count > 0)
{
TaglistBox.SelectedIndex = 0;
}
cnn.Close(); cnn.Dispose();
newRecord = false;
}
[InlineData(MoneyManipulationOperation.Withdraw, 101, -1)] //should be failed
public async Task MoneyOperation_MakeWithdrawAndCharge_CheckResult(MoneyManipulationOperation mmo, float fakeAmount, float expectedResult)
{
//arrange
var fakeAccountId = 1;
var fakeCurrency = new CurrencyRecord {
Id = 1, Name = "FAKE"
};
var fakeWallet = new WalletRecord {
CashValue = 100
};
var userServiceMock = new Mock <IUserService>();
userServiceMock
.Setup(x => x.FindCurrencyAsync(It.IsAny <string>()))
.ReturnsAsync(fakeCurrency);
userServiceMock
.Setup(x => x.FindUserWalletAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(fakeWallet);
var adminController = new AdminController(userServiceMock.Object, _adminServiceMock.Object, _dbMock.Object);
//act
var result = await adminController.MoneyOperation(mmo, fakeCurrency.Name, fakeAccountId, fakeAmount);
//assert
if (expectedResult == -1)
{
Assert.IsType <BadRequestObjectResult>(result);
}
else
{
Assert.Equal(expectedResult, fakeWallet.CashValue);
}
}
public CurrencyConversionModel CalculateAmountForCurrencyConversion(CurrencyConversionModel currencyConversionModel)
{
CurrencyRecord firstDesiredCurrency = GetDesiredCurrency(currencyConversionModel.FirstCurrency, currencyConversionModel.Date);
CurrencyRecord secondDesiredCurrency = GetDesiredCurrency(currencyConversionModel.SecondCurrency, currencyConversionModel.Date);
currencyConversionModel.AmountSecondCurrency = currencyConversionModel.AmountFirstCurrency * firstDesiredCurrency.Close / secondDesiredCurrency.Close;
return(currencyConversionModel);
}
private async Task <CurrencyRecord> GetDesiredCurrency(string nameCurrency, DateTime date)
{
Currency currency = await _repository.GetCurrency(nameCurrency);
List <CurrencyRecord> listOfRecords = currency.ListOfRecords;
CurrencyRecord desiredRecord = listOfRecords.SingleOrDefault(record => record.Date == date);
return(desiredRecord);
}
private CurrencyRecord GetDesiredCurrency(string nameCurrency, DateTime date)
{
nameCurrency += ".txt";
Currency currency = _loader.LoadCurrencyFromFile(nameCurrency);
List <CurrencyRecord> listOfRecords = currency.ListOfRecords;
CurrencyRecord desiredRecord = listOfRecords.SingleOrDefault(record => record.Date == date);
return(desiredRecord);
}
private static void CreateUserCommission(this ModelBuilder builder, UserRecord user,
CommissionRecord commissionPattern, CurrencyRecord currency, OperationType type, int mul)
{
var commission = commissionPattern.CreateSameCommission(type, mul * commissionPattern.Id + 1);
commission.CurrencyId = currency.Id;
commission.UserId = user.Id;
builder.Entity <CommissionRecord>().HasData(commission);
}
public async Task <CurrencyConversionModel> CalculateCurrencyConversionAmount(CurrencyConversionModel currencyConversionModel)
{
CurrencyRecord firstDesiredCurrency = await GetDesiredCurrency(currencyConversionModel.FirstCurrency, currencyConversionModel.Date);
CurrencyRecord secondDesiredCurrency = await GetDesiredCurrency(currencyConversionModel.SecondCurrency, currencyConversionModel.Date);
currencyConversionModel.AmountSecondCurrency = currencyConversionModel.AmountFirstCurrency * firstDesiredCurrency.Close / secondDesiredCurrency.Close;
return(currencyConversionModel);
}
private static CurrencyRecord CreateCurrency(this ModelBuilder builder, string name, int id)
{
var currency = new CurrencyRecord
{
Id = id, Name = name
};
builder.Entity <CurrencyRecord>().HasData(currency);
return(currency);
}
private static void CreateWallet(this ModelBuilder builder, CurrencyRecord currency,
AccountRecord account, double value, int id)
{
var wallet = new WalletRecord
{
Id = id, CurrencyId = currency.Id, AccountId = account.Id,
Value = value
};
builder.Entity <WalletRecord>().HasData(wallet);
}
public Price ConvertPrice(double priceValue, CurrencyRecord currencyFrom, string currencyTo)
{
var c = _currencies.Table.FirstOrDefault(aa => aa.Code == currencyTo);
if (c == null)
{
return new Price()
{
Value = priceValue, Currency = currencyFrom
}
}
;
return(ConvertPrice(priceValue, currencyFrom, c));
}
public async Task Operation_ConfirmLimitCondition_ReturnsOkWithNewRequests()
{
//arrange
var fakeUser = TestUser();
var fakeAmount = 1000.0f;
var fakeCurrency = new CurrencyRecord {
Id = 1, Name = "FAKE", ConfirmLimit = 999.9f
};
var fakeAccount = TestUserAccount();
var fakeWallet = new WalletRecord {
CashValue = 1000
};
var userServiceMock = new Mock <IUserService>();
userServiceMock
.Setup(x => x.FindCurrencyAsync(It.IsAny <string>()))
.ReturnsAsync(fakeCurrency);
userServiceMock
.Setup(x => x.FindUserWalletAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(fakeWallet);
userServiceMock
.Setup(x => x.FindUserAccountAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(fakeAccount);
userServiceMock
.Setup(x => x.FindUserByNameAsync(It.IsAny <string>()))
.ReturnsAsync(fakeUser);
userServiceMock
.Setup(x => x.FindCurrencyCommissionAsync(It.IsAny <int>()))
.ReturnsAsync(null as CommissionRecord);
userServiceMock
.Setup(x => x.FindUserCommissionAsync(It.IsAny <int>()))
.ReturnsAsync(null as CommissionRecord);
var accountController = new AccountController(userServiceMock.Object, _dbMock.Object)
{
ControllerContext = _controllerContext
};
//act
var result = await accountController.Operation(fakeAccount.Id, OperationType.Deposit, fakeAmount, fakeCurrency.Name, null);
//assert
Assert.IsType <OkObjectResult>(result);
userServiceMock.Verify(x => x.AddRequestToConfirmAsync(It.IsAny <OperationType>(),
It.IsAny <AccountRecord>(),
It.IsAny <AccountRecord>(),
It.IsAny <float>(),
It.IsAny <float>(),
It.IsAny <string>()));
}
private Currency CreateTestCurrency(int startValue)
{
Currency testCurrency = new Currency();
for (int i = 0; i <= 7; i++)
{
CurrencyRecord currencyRecord = new CurrencyRecord
{
Date = new DateTime(_date.Year, _date.Month, _date.Day + i),
Close = startValue + i
};
testCurrency.ListOfRecords.Add(currencyRecord);
}
return(testCurrency);
}
public async Task Operation_WithdrawMoneyWithCommission_VerifyResult()
{
//arrange
var fakeUser = TestUser();
var fakeAmount = 1000.0f;
var fakeCurrency = new CurrencyRecord {
Id = 1, Name = "FAKE"
};
var fakeAccount = TestUserAccount();
var fakeWallet = new WalletRecord {
CashValue = 1010
};
var fakeCommission = new CommissionRecord {
CurrencyId = 1, WithdrawCommission = 10, IsAbsoluteType = true
};
var userServiceMock = new Mock <IUserService>();
userServiceMock
.Setup(x => x.FindCurrencyAsync(It.IsAny <string>()))
.ReturnsAsync(fakeCurrency);
userServiceMock
.Setup(x => x.FindUserWalletAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(fakeWallet);
userServiceMock
.Setup(x => x.FindUserAccountAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(fakeAccount);
userServiceMock
.Setup(x => x.FindUserByNameAsync(It.IsAny <string>()))
.ReturnsAsync(fakeUser);
userServiceMock
.Setup(x => x.FindCurrencyCommissionAsync(It.IsAny <int>()))
.ReturnsAsync(fakeCommission);
userServiceMock
.Setup(x => x.FindUserCommissionAsync(It.IsAny <int>()))
.ReturnsAsync(null as CommissionRecord);
var accountController = new AccountController(userServiceMock.Object, _dbMock.Object)
{
ControllerContext = _controllerContext
};
//act
await accountController.Operation(fakeAccount.Id, OperationType.Withdraw, fakeAmount, fakeCurrency.Name, null);
//assert
Assert.Equal(0, fakeWallet.CashValue);
}
private Currency CreateTestCurrency(int startingPoint, int startYear, int startMonth)
{
Currency testCurrency = new Currency();
// Creates 7 additional, concurent days to currency.
for (int i = startingPoint; i <= startingPoint + 7; i++)
{
CurrencyRecord currencyRecord = new CurrencyRecord
{
Date = new DateTime(startYear, startMonth, i)
};
testCurrency.ListOfRecords.Add(currencyRecord);
}
return(testCurrency);
}
public async Task Confirm_VerifyConfirmationAndAddingToOperationsHistory_ReturnOk()
{
var fakeCurrency = new CurrencyRecord {
Id = 1, Name = "FAKE"
};
var fakeWallet = new WalletRecord {
CashValue = 50
};
var fakeUser = new UserRecord {
Id = 1
};
var fakeConfirmRequest = new ConfirmRequestRecord
{
Currency = "FAKE",
OperationType = OperationType.Deposit,
SenderId = 1,
Amount = 45,
Commission = 0.0f
};
var adminServiceMock = new Mock <IAdminService>();
adminServiceMock
.Setup(x => x.FindRequestToConfirm(It.IsAny <int>()))
.ReturnsAsync(fakeConfirmRequest);
var userServiceMock = new Mock <IUserService>();
userServiceMock
.Setup(x => x.FindCurrencyAsync(fakeConfirmRequest.Currency))
.ReturnsAsync(fakeCurrency);
userServiceMock
.Setup(x => x.FindUserByAccountIdAsync(fakeConfirmRequest.SenderId))
.ReturnsAsync(fakeUser);
userServiceMock
.Setup(x => x.FindUserWalletAsync(fakeConfirmRequest.SenderId, fakeCurrency.Id))
.ReturnsAsync(fakeWallet);
var adminController = new AdminController(userServiceMock.Object, adminServiceMock.Object, _dbMock.Object);
//act
var result = await adminController.Confirm(It.IsAny <int>());
//assert
Assert.IsType <OkObjectResult>(result);
Assert.Equal(RequestStatus.Completed, fakeConfirmRequest.Status);
userServiceMock.Verify(x => x.AddOperationHistoryAsync(fakeConfirmRequest.OperationType, fakeUser.Id, fakeConfirmRequest.SenderId,
fakeConfirmRequest.Amount, fakeConfirmRequest.Commission, fakeCurrency.Name));
}
public async Task CreateCurrency(string name, CommissionDto dto)
{
var currency = new CurrencyRecord {
Name = name
};
await _context.Currencies.AddAsync(currency);
await _context.SaveChangesAsync();
var deposit = CommissionManager.CreateCommission(currency.Id, dto, OperationType.Deposit);
var transfer = CommissionManager.CreateCommission(currency.Id, dto, OperationType.Transfer);
var withdrawal = CommissionManager.CreateCommission(currency.Id, dto, OperationType.Withdrawal);
await _context.Commissions.AddRangeAsync(deposit, transfer, withdrawal);
await _context.SaveChangesAsync();
}
public CurrenciesComparatorModel CompareCurrencies(CurrenciesComparatorModel model)
{
Currency firstCurrency = _loader.LoadCurrencyFromFile(model.FirstCurrencyCode + FileExtension);
Currency secondCurrency = _loader.LoadCurrencyFromFile(model.SecondCurrencyCode + FileExtension);
CurrencyRecord firstCurrencyRecord =
firstCurrency.ListOfRecords.Single(currency => currency.Date == model.Date);
CurrencyRecord secondCurrencyRecord =
secondCurrency.ListOfRecords.Single(currency => currency.Date == model.Date);
float firstCloseValue = firstCurrencyRecord.Close;
float secondCloseValue = secondCurrencyRecord.Close;
float comparision = firstCloseValue / secondCloseValue;
model.ComparatorResult = $"In day {model.Date.ToShortDateString()} {firstCurrency.Name} is worth {comparision} {secondCurrency.Name}";
return(model);
}
private Currency CreateTestCurrency(string name)
{
Currency testCurrency = new Currency();
Random random = new Random();
for (int i = 1; i <= random.Next(3, 10); i++)
{
CurrencyRecord currencyRecord = new CurrencyRecord
{
Date = new DateTime(2000, 10, i)
};
testCurrency.ListOfRecords.Add(currencyRecord);
}
testCurrency.Name = name;
return(testCurrency);
}
private Currency CreateCurrency(string CurrencyName, DateTime startDate, int numberOfDays)
{
Currency currency = new Currency();
List <CurrencyRecord> records = new List <CurrencyRecord>();
for (int i = 0; i < numberOfDays; i++)
{
CurrencyRecord newRecord = new CurrencyRecord()
{
Date = startDate.AddDays(i),
};
records.Add(newRecord);
}
currency.Name = _firstCurrencyName;
currency.ListOfRecords = records;
return(currency);
}
public async Task <CurrenciesComparatorModel> CompareCurrencies(CurrenciesComparatorModel model)
{
Currency firstCurrency = await _currencyRepository.GetCurrency(model.FirstCurrencyCode);
Currency secondCurrency = await _currencyRepository.GetCurrency(model.SecondCurrencyCode);
CurrencyRecord firstCurrencyRecord =
firstCurrency.ListOfRecords.Single(currency => currency.Date == model.Date);
CurrencyRecord secondCurrencyRecord =
secondCurrency.ListOfRecords.Single(currency => currency.Date == model.Date);
float firstCloseValue = firstCurrencyRecord.Close;
float secondCloseValue = secondCurrencyRecord.Close;
float comparision = firstCloseValue / secondCloseValue;
model.ComparatorResult = $"On the day of {model.Date.ToShortDateString()} {firstCurrency.Name} is worth {comparision} {secondCurrency.Name}";
return(model);
}
private Currency CreateCurrency(int startDay, int startMonth, int startYear, string name,
float startCloseValue, float incrementCloseValue)
{
Currency testCurrency = new Currency();
// Creates 7 additional, concurent days to currency.
for (int i = startDay; i <= startDay + 7; i++)
{
CurrencyRecord currencyRecord = new CurrencyRecord
{
Date = new DateTime(startYear, startMonth, i),
Close = startCloseValue + i * incrementCloseValue,
High = startCloseValue + i * incrementCloseValue + incrementCloseValue,
Low = startCloseValue + i * incrementCloseValue - incrementCloseValue
};
testCurrency.ListOfRecords.Add(currencyRecord);
}
testCurrency.Name = name;
return(testCurrency);
}
public Price ConvertPrice(double priceValue, CurrencyRecord currencyFrom, ExchangeRateFor exchangeRateFor)
{
if (currencyFrom == CurrentUserCurrency)
{
return(new Price
{
Value = priceValue,
Currency = currencyFrom
});
}
var currencyExchange = CurrencyExchanges
.First(e => e.CurrencyFrom == currencyFrom &&
e.CurrencyTo == CurrentUserCurrency);
double exchangeRate;
switch (exchangeRateFor)
{
case ExchangeRateFor.Buyer:
exchangeRate = currencyExchange.RateForBuyer;
break;
case ExchangeRateFor.Seller:
exchangeRate = currencyExchange.RateForSeller;
break;
default:
throw new ArgumentOutOfRangeException("exchangeRateFor", exchangeRateFor, null);
}
var convertedPrice = new Price
{
Value = priceValue * exchangeRate,
Currency = CurrentUserCurrency
};
return(convertedPrice);
}
public ActionResult AddCurrency(CurrencyViewModel viewModel)
{
var currency = new CurrencyRecord
{
Code = viewModel.Code,
Name = viewModel.Name,
ShortName = viewModel.ShortName,
CurrencyCulture = _cultureUsed
};
bool isNotPng;
currency.FlagFileName = _imageFileHelper.SaveImageToDisc(viewModel.FlagImage, currency.Id, out isNotPng);
if (isNotPng)
{
_orchardServices.Notifier.Error(T("Flag Image file must be *.png."));
return(RedirectToAction("Index"));
}
var countryCurrency = new LinkCountryCurrencyRecord
{
CurrencyRecord = currency
};
if (viewModel.CountryId.HasValue)
{
var country = _countryRepository.Get(viewModel.CountryId.Value);
countryCurrency.CountryRecord = country;
}
currency.CountryCurrencies.Add(countryCurrency);
_currencyRepository.Create(currency);
_orchardServices.Notifier.Information(T("Currency has been added!"));
return(RedirectToAction("Index"));
}
private Currency CreateCurrency(int CloseValue, string CurrencyName, DateTime commonDate)
{
Currency currency = new Currency();
List <CurrencyRecord> records = new List <CurrencyRecord>();
CurrencyRecord firstRecord = new CurrencyRecord()
{
Date = commonDate,
Close = CloseValue
};
CurrencyRecord secondRecord = new CurrencyRecord()
{
Date = new DateTime(1000, 1, 1),
Close = 15
};
records.Add(firstRecord);
records.Add(secondRecord);
currency.Name = _firstCurrencyName;
currency.ListOfRecords = records;
return(currency);
}
public async Task CurrencyLimitOperation_SetLimits_CheckLimits(float?lowerLim, float?upperLim,
float?confirmLim)
{
var fakeCurrency = new CurrencyRecord {
Id = 1, Name = "FAKE"
};
var userServiceMock = new Mock <IUserService>();
userServiceMock
.Setup(x => x.FindCurrencyAsync(It.IsAny <string>()))
.ReturnsAsync(fakeCurrency);
var adminController = new AdminController(userServiceMock.Object, _adminServiceMock.Object, _dbMock.Object);
//act
var result = await adminController.CurrencyLimitOperation(fakeCurrency.Name, lowerLim, upperLim, confirmLim);
//assert
Assert.Equal(lowerLim, fakeCurrency.LowerCommissionLimit);
Assert.Equal(upperLim, fakeCurrency.UpperCommissionLimit);
Assert.Equal(confirmLim, fakeCurrency.ConfirmLimit);
Assert.IsType <OkObjectResult>(result);
_dbMock.Verify(x => x.SaveChangesAsync(It.IsAny <CancellationToken>()));
}
public async Task Operation_MakeMoneyReductionOperations_ReturnOperationDenied(OperationType operationType, string toUserName)
{
//arrange
var fakeUser = TestUser();
var fakeAmount = 100.0f;
var fakeCurrency = new CurrencyRecord {
Id = 1, Name = "FAKE"
};
var fakeAccount = TestUserAccount();
var userServiceMock = new Mock <IUserService>();
userServiceMock
.Setup(x => x.FindCurrencyAsync(It.IsAny <string>()))
.ReturnsAsync(fakeCurrency);
userServiceMock
.Setup(x => x.FindUserWalletAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(null as WalletRecord);
userServiceMock
.Setup(x => x.FindUserAccountAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(fakeAccount);
userServiceMock
.Setup(x => x.FindUserByNameAsync(It.IsAny <string>()))
.ReturnsAsync(fakeUser);
var accountController = new AccountController(userServiceMock.Object, _dbMock.Object)
{
ControllerContext = _controllerContext
};
//act
var result = await accountController.Operation(fakeAccount.Id, operationType, fakeAmount, fakeCurrency.Name, toUserName);
//assert
Assert.IsType <BadRequestObjectResult>(result);
userServiceMock.Verify(x => x.FindUserWalletAsync(It.IsAny <int>(), It.IsAny <int>()));
}
public HttpStatusCodeResult LaunchCampaign(LaunchCampaignData data)
{
CurrencyRecord currencyRecod = null;
if (data.Currency.HasValue)
{
currencyRecod = _currencyRepository.Table.FirstOrDefault(aa => aa.Id == data.Currency.Value);
}
else
{
currencyRecod = _currencyRepository.Table.FirstOrDefault(aa => aa.Code == "USD");
}
if (currencyRecod == null)
{
_currencyRepository.Table.FirstOrDefault(aa => aa.Code == "USD");
}
if (string.IsNullOrWhiteSpace(data.CampaignTitle) && string.IsNullOrWhiteSpace(data.Description) &&
string.IsNullOrWhiteSpace(data.Alias))
{
var error = "name|" + T("Campaign Title can't be empty") + "|campaign_description_text|" +
T("Campaign Description can't be empty") + "|url|" +
T("Campaign URL can't be empty");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (string.IsNullOrWhiteSpace(data.CampaignTitle) && string.IsNullOrWhiteSpace(data.Description))
{
var error = "name|" + T("Campaign Title can't be empty") + "|campaign_description_text|" +
T("Campaign Description can't be empty");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (string.IsNullOrWhiteSpace(data.CampaignTitle) && string.IsNullOrWhiteSpace(data.Alias))
{
var error = "name|" + T("Campaign Title can't be empty") + "|url|" +
T("Campaign URL can't be empty");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (string.IsNullOrWhiteSpace(data.Description) && string.IsNullOrWhiteSpace(data.Alias))
{
var error = "campaign_description_text|" + T("Campaign Description can't be empty") +
"|url|" + T("Campaign URL can't be empty");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (string.IsNullOrWhiteSpace(data.CampaignTitle))
{
var error = "name|" + T("Campaign Title can't be empty");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (string.IsNullOrWhiteSpace(data.Description))
{
var error = "campaign_description_text|" + T("Campaign Description can't be empty");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (string.IsNullOrWhiteSpace(data.Alias))
{
var error = "url|" + T("Campaign URL can't be empty");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
data.Alias = data.Alias.Trim();
if (data.Alias.Any(ch => char.IsWhiteSpace(ch)))
{
var error = "url|" + T("Campaign URL can't contain whitespaces");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (data.Alias.Contains('&') || data.Alias.Contains('?') || data.Alias.Contains('/') ||
data.Alias.Contains('\\'))
{
var error = "url|" + T("Campaign URL has wrong format");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (_campaignService.GetCampaignByAlias(data.Alias) != null)
{
var error = "url|" + T("Campaign with this URL already exists");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (data.Alias.Length < 4)
{
var error = "url|" + T("Campaign URL must be at least 4 characters long");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (string.IsNullOrWhiteSpace(data.Design))
{
var error = "Design|" + T("No design found for your campaign");
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, error));
}
if (_orchardServices.WorkContext.CurrentUser == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden));
}
var campaignCurrency = _currencyRepository.Get(data.CampaignCurrencyId);
//if (campaignCurrency != _priceConversionService.CurrentUserCurrency)
//{
// var error = T("Campaign currency is not the same as user currency").ToString();
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest, error);
//}
try
{
foreach (var prod in data.Products)
{
double price;
if (!double.TryParse(prod.Price, out price))
{
double.TryParse(prod.Price.Replace('.', ','), out price);
}
double cost;
if (!double.TryParse(prod.BaseCost, out cost))
{
double.TryParse(prod.BaseCost.Replace('.', ','), out cost);
}
if (price < cost)
{
prod.Price = prod.BaseCost;
}
}
data.CampaignCulture = _cultureUsed;
////TODO: (auth:keinlekan) После удаления поля в таблице/моделе - удалить данный код
var campaign = _campaignService.CreateNewCampiagn(data);
CreateImagesForCampaignProducts(campaign);
var pathToTemplates = Server.MapPath("/Modules/Teeyoot.Module/Content/message-templates/");
var pathToMedia = Request.Url.Scheme + "://" + Request.Url.Authority +
Request.ApplicationPath.TrimEnd('/');
_teeyootMessagingService.SendNewCampaignAdminMessage(pathToTemplates, pathToMedia, campaign.Id);
////TODO: add conditional here to allow admin to set setting for it, is campaign is auto-approved or not.
Approve(campaign.Id);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
catch (Exception e)
{
Logger.Log(LogLevel.Error, e, "", null);
Logger.Error("Error occured when trying to create new campaign ---------------> " + e);
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError,
T("Error occured when trying to create new campaign").ToString()));
}
}
private static void CreateCurrencyEqualCommissions(this ModelBuilder builder,
CommissionRecord commissionPattern, CurrencyRecord currency, int mul)
{
commissionPattern.CurrencyId = currency.Id;
builder.Entity <CommissionRecord>().HasData(
commissionPattern.CreateSameCommission(OperationType.Deposit, mul * commissionPattern.Id + 1),
commissionPattern.CreateSameCommission(OperationType.Withdrawal, mul * commissionPattern.Id + 2),
commissionPattern.CreateSameCommission(OperationType.Transfer, mul * commissionPattern.Id + 3));
}
