public async Task <IActionResult> Post(AdvertisingModel advertisingModel)
{
AdvertisingModel advertising;
if (advertisingModel == null)
{
advertising = await db.Advertisings.CreateAsync(new AdvertisingModel
{
AdvertisingName = "",
Text = "",
ImagePath = "",
ItemPrice = "",
AdvertisingCategoryId = 0
});
return(Ok(advertising));
}
else if (advertisingModel.ImagePath == null || advertisingModel.ImagePath == "")
{
advertisingModel.ImagePath = "/assets/images/no_photo.png";
}
if (advertisingModel.ItemPrice == null || advertisingModel.ItemPrice == "")
{
advertisingModel.ItemPrice = "Договорная";
}
else
{
advertisingModel.ItemPrice += " р.";
}
advertising = await db.Advertisings.CreateAsync(advertisingModel);
return(Ok(advertising));
}
private Advertising GetAdvertisingFromModel(AdvertisingModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (advertisingRepository.Set().Any(a => a.Id == model.AdvertisingId))
{
throw new ArgumentException($"Advertising id {model.AdvertisingId} is already taken", nameof(model));
}
var image = imageRepository.Set().FirstOrDefault(i => i.Id == model.ImageId);
if (image == null && model.ImageUri != default)
{
image = new Image
{
Uri = model.ImageUri
};
}
return(new Advertising
{
Image = image,
IsActive = (bool)model.IsActive,
Url = model.Url,
DateCreated = (DateTime)model.DateCreated
});
}
public void OnGetAdvertising(AdvertisingModel adv)
{
if (OnGetAdvertisingEvent != null)
{
OnGetAdvertisingEvent(adv);
}
}
public async Task <IActionResult> Get(int id)
{
if (id <= 0)
{
return(BadRequest());
}
AdvertisingModel advertising = await db.Advertisings.GetItemByIdAsync(id);
if (advertising == null)
{
return(NotFound());
}
var category = await db.AdvertisingCategories.GetItemByIdAsync(advertising.AdvertisingCategoryId);
AdFullModel adFullModel = new AdFullModel
{
Id = advertising.Id,
AdvertisingName = advertising.AdvertisingName,
Text = advertising.Text,
ImagePath = advertising.ImagePath,
ItemPrice = advertising.ItemPrice,
AdvertisingCategoryId = advertising.AdvertisingCategoryId,
CategoryName = category.CategoryName,
UserId = advertising.UserId
};
return(Ok(adFullModel));
}
public IActionResult GetAd(AdLocation type)
{
var adv = new AdvertisingModel();
if (type.Equals(AdLocation.Home))
{
adv.AdName = "测试";
}
return(Json(type));
}
public IActionResult Update(int id, [FromBody] AdvertisingModel param)
{
AssignModelState();
var response = _advertisingService.Edit(param);
if (response.Success)
{
return(Ok(response.Item));
}
return(BadRequest(response.Message));
}
public void AddNewAdvertisingLocalizationFromModel(AdvertisingModel model)
{
var advertisingLocalization = GetAdvertisingLocalizationFromModel(model);
if (advertisingLocalizationRepository.Set()
.Any(al => al.AdvertisingId == model.AdvertisingId && al.LanguageId == model.LanguageId))
{
throw new ArgumentException($"localization in language {model.LanguageId} for advertising {model.AdvertisingId} already exists", nameof(model));
}
advertisingLocalizationRepository.Insert(advertisingLocalization);
}
public void AddNewCategoryAdFromModel(AdvertisingModel model)
{
var categoryAd = GetCategoryAdFromModel(model);
if (categoryAdRepository.Set()
.Any(al => al.AdvertisingId == model.AdvertisingId && al.CategoryId == model.CategoryId))
{
throw new ArgumentException($"CategoryAd in category {model.CategoryId} for advertising {model.AdvertisingId} already exists", nameof(model));
}
categoryAdRepository.Insert(categoryAd);
}
public async Task <AdvertisingModel> CreateAsync(AdvertisingModel item)
{
if (item != null)
{
db.Advertisings.Add(item);
await db.SaveChangesAsync();
return(item);
}
return(null);
}
public async Task <AdvertisingModel> DeleteAsync(int id)
{
AdvertisingModel item = await db.Advertisings.FindAsync(id);
if (item != null)
{
db.Advertisings.Remove(item);
await db.SaveChangesAsync();
return(item);
}
return(null);
}
public async Task <IActionResult> Put(int id, AdvertisingModel advertisingModel)
{
if (advertisingModel == null)
{
return(BadRequest());
}
if (id != advertisingModel.Id)
{
return(BadRequest());
}
await db.Advertisings.UpdateAsync(advertisingModel);
return(Ok(advertisingModel));
}
public void UpdateAdvertisingLocalizationFromModel(AdvertisingModel model)
{
var originalAdvertisingLocalization = advertisingLocalizationRepository.Set()
.FirstOrDefault(al => al.AdvertisingId == model.AdvertisingId && al.LanguageId == model.LanguageId);
if (originalAdvertisingLocalization == null)
{
throw new ArgumentException($"no localization in language {model.LanguageId} of advertising {model.AdvertisingId}", nameof(model));
}
var newAdvertisingLocalization = GetAdvertisingLocalizationFromModel(model);
originalAdvertisingLocalization.Headline = newAdvertisingLocalization.Headline;
advertisingLocalizationRepository.Update(originalAdvertisingLocalization);
}
public void SetAdvertisingLobby(AdvertisingModel adv)
{
Task.Factory.StartNew(() =>
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
AdsMiniRight.Tag = adv;
this.AdsLoader.Visibility = Visibility.Visible;
var image = new Image();
var fullFilePath = @adv.Image;
BitmapImage imgBitmap = new BitmapImage();
imgBitmap.BeginInit();
imgBitmap.UriSource = new Uri(fullFilePath, UriKind.Absolute);
imgBitmap.UriCachePolicy = new RequestCachePolicy(RequestCacheLevel.Default);
imgBitmap.CacheOption = BitmapCacheOption.OnLoad;
imgBitmap.DownloadCompleted += (o, e) =>
{
ImageBrush b = new ImageBrush(imgBitmap);
b.AlignmentX = AlignmentX.Center;
b.AlignmentY = AlignmentY.Center;
b.Stretch = Stretch.UniformToFill;
this.AdsMiniRight.Background = b;
this.AdsLoader.Visibility = Visibility.Hidden;
};
imgBitmap.DownloadFailed += (o, e) =>
{
SetAdvertisingLobby(adv);
};
imgBitmap.EndInit();
//Z cache
if (imgBitmap.IsDownloading == false)
{
ImageBrush b = new ImageBrush(imgBitmap);
b.AlignmentX = AlignmentX.Center;
b.AlignmentY = AlignmentY.Center;
b.Stretch = Stretch.UniformToFill;
this.AdsMiniRight.Background = b;
this.AdsLoader.Visibility = Visibility.Hidden;
}
}));
});
}
public void UpdateAdvertisingById(int id, AdvertisingModel model)
{
var originalAdvertising = advertisingRepository.Set().FirstOrDefault(a => a.Id == id);
if (originalAdvertising == null)
{
throw new ArgumentException($"can\'t find advertising {id}", nameof(id));
}
var advertising = GetAdvertisingFromModel(model);
originalAdvertising.Image = advertising.Image;
originalAdvertising.Url = advertising.Url;
originalAdvertising.IsActive = advertising.IsActive;
originalAdvertising.DateCreated = advertising.DateCreated;
advertisingRepository.Update(originalAdvertising);
}
private CategoryAd GetCategoryAdFromModel(AdvertisingModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var category = categoryRepository.Set().FirstOrDefault(l => l.Id == model.CategoryId);
var advertising = advertisingRepository.Set().FirstOrDefault(l => l.Id == model.AdvertisingId);
if (category == null || advertising == null)
{
throw new ArgumentException($"can\'t find category {model.CategoryId} or advertising {model.AdvertisingId}", nameof(model));
}
return(new CategoryAd
{
Advertising = advertising,
Category = category,
Displayed = model.Displayed,
Opened = model.Opened
});
}
private AdvertisingLocalization GetAdvertisingLocalizationFromModel(AdvertisingModel model)
{
var language = languageRepository.Set().FirstOrDefault(l => l.Id == model.LanguageId);
if (language == null)
{
throw new ArgumentException($"can\'t find language {model.LanguageId}", nameof(model));
}
var advertising = advertisingRepository.Set().FirstOrDefault(l => l.Id == model.AdvertisingId);
if (advertising == null)
{
throw new ArgumentException($"can\'t find advertising {model.AdvertisingId}", nameof(model));
}
return(new AdvertisingLocalization
{
Advertising = advertising,
Language = language,
Headline = model.Headline
});
}
public async Task UpdateAsync(AdvertisingModel item)
{
db.Entry(item).State = EntityState.Modified;
await db.SaveChangesAsync();
}
public async Task UpdateAsync(AdvertisingModel item)
{
await db.UpdateAsync(item);
}
public async Task <AdvertisingModel> CreateAsync(AdvertisingModel item)
{
return(await db.CreateAsync(item));
}
public void AddAdvertisingFromModel(AdvertisingModel model)
{
var advertising = GetAdvertisingFromModel(model);
advertisingRepository.Insert(advertising);
}
