private async Task ProcessCurrencies()
{
try
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("X-IBM-client-id", configurationBuilder["ClientId"]);
client.DefaultRequestHeaders.Add("X-IBM-client-secret", configurationBuilder["ClientSecret"]);
var clientResponse = await client.GetAsync(configurationBuilder["ClientUrl"] + currencyType + "/?date=" + DateTime.Now.ToShortDateString());
if (clientResponse.IsSuccessStatusCode)
{
dynamic response = JsonConvert.DeserializeObject(clientResponse.Content.ReadAsStringAsync().Result);
CurrencyModel model = new CurrencyModel();
model.RateBuy = response.data.rate_buy;
model.RateSell = response.data.rate_sell;
var serviceResponse = currencyService.Create(model);
if (string.IsNullOrEmpty(serviceResponse.Id))
{
Console.WriteLine("Write operation failed");
}
Console.WriteLine("Success");
}
}
catch (Exception ex)
{
Console.WriteLine("Exception: " + ex.Message);
}
}
public void CreateCurrency(Guid id, string name, string displayMessage)
{
try
{
_savedCurrency = _currencyService.Create(id, name, displayMessage);
}
catch (DomainValidationException dex)
{
_domainValidationException = dex;
}
}
public ActionResult Create(CurrencyViewModel viewmodel)
{
try
{
_currencyService.Create(Guid.NewGuid(), viewmodel.Name, viewmodel.DisplayMessage);
}
catch (DomainValidationException dex)
{
ModelState.UpdateFromDomain(dex.Result);
}
return(RedirectToAction("Index"));
}
public async void Create()
{
var mock = new ServiceMockFacade <ICurrencyRepository>();
var model = new ApiCurrencyRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Currency>())).Returns(Task.FromResult(new Currency()));
var service = new CurrencyService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.CurrencyModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLCurrencyMapperMock,
mock.DALMapperMockFactory.DALCurrencyMapperMock,
mock.BOLMapperMockFactory.BOLCurrencyRateMapperMock,
mock.DALMapperMockFactory.DALCurrencyRateMapperMock);
CreateResponse <ApiCurrencyResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
mock.ModelValidatorMockFactory.CurrencyModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiCurrencyRequestModel>()));
mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Currency>()));
}
public IActionResult Create([FromBody] Currency currency)
{
if (currency != null)
{
if (!service.IsCurrencyExist(currency.CurrencyName))
{
service.Create(currency);
}
else
{
service.Update(currency);
IEnumerable <Product> products = productService.GetList();
foreach (var item in products)
{
productService.Update(item);
}
}
return(Ok());
}
return(BadRequest());
}
private void CreateBasicMaping(StructureInfo structureInfo)
{
//Visitor Group
structureInfo.Mappings.Add(structureInfo.Foundation.VisitorGroupId, (_groupService.Get <Group>("Visitors") ?? _groupService.Get <Group>("Besökare"))?.SystemId ?? CreateVisitorGroup());
//Language Map
foreach (var item in structureInfo.Foundation.LanguageMap)
{
var culture = new CultureInfo(item.Value);
structureInfo.Mappings.Add(item.Key,
Solution.Instance.Languages.Exists(culture)
? Solution.Instance.Languages[culture].ID
: Solution.Instance.Languages.CreateLanguage(culture.NativeName, culture, false,
ModuleProductCatalog.Instance.AdminToken).ID);
}
//Currency Map
foreach (var item in structureInfo.Foundation.Currencies)
{
var cu = _currencyService.Get(item.Id);
if (cu == null)
{
cu = new Currency(item.Id);
_currencyService.Create(cu);
}
if (!structureInfo.Mappings.ContainsKey(item.SystemId))
{
structureInfo.Mappings.Add(item.SystemId, cu.SystemId);
}
}
//Relation map
if (structureInfo.Foundation.RelationTemplates != null)
{
var relationTemplates = _fieldTemplateService.GetAll().ToList();
foreach (var template in structureInfo.Foundation.RelationTemplates)
{
var fieldTemplate = relationTemplates.FirstOrDefault(x => x.Id == template.Value);
if (fieldTemplate != null)
{
structureInfo.Mappings.Add(template.Key, fieldTemplate.SystemId);
}
}
}
// Template
foreach (var marketTemplate in structureInfo.Website.MarketTemplateMap)
{
var template = _fieldTemplateService.Get <MarketFieldTemplate>(marketTemplate.Value);
structureInfo.Mappings.Add(marketTemplate.Key, template?.SystemId ?? Guid.Empty);
}
// Market mappings
structureInfo.Mappings.Add(structureInfo.Website.Market.SystemId, Guid.NewGuid());
//Channel
foreach (var channelTemplate in structureInfo.Website.ChannelTemplateMap)
{
var template = _fieldTemplateService.Get <ChannelFieldTemplate>(channelTemplate.Value);
structureInfo.Mappings.Add(channelTemplate.Key, template?.SystemId ?? Guid.Empty);
}
structureInfo.Mappings.Add(structureInfo.Website.Channel.SystemId, Guid.NewGuid());
//Website
structureInfo.Mappings.Add(structureInfo.Website.Website.SystemId, Guid.NewGuid());
foreach (var websiteTemplate in structureInfo.Website.WebsiteTemplateMap)
{
var template = _fieldTemplateService.Get <WebsiteFieldTemplate>(websiteTemplate.Value);
structureInfo.Mappings.Add(websiteTemplate.Key, template?.SystemId ?? Guid.Empty);
}
}
