public IActionResult Post([FromQuery] AdDTO ad)
{
var ads = new Ad
{
Title = ad.Title,
Body = ad.Body,
Price = ad.Price,
IsShipping = ad.IsShipping
};
_context.Ads.Add(ads);
try
{
_context.SaveChanges();
return(Created("/api/ads/" + ads.Id, new AdDTO
{
Id = ads.Id,
Title = ad.Title,
Body = ad.Body,
Price = ad.Price,
IsShipping = ad.IsShipping
}));
}
catch
{
return(StatusCode(500, "An error has occured."));
}
}
public async Task <IHttpActionResult> UnblockAd([FromUri] int adId)
{
AdDTO ad = await uow.AdService.GetAdById(adId);
if (ad == null)
{
return(NotFound());
}
if (!ad.IsBlocked)
{
return(BadRequest("Ad is not blocked."));
}
var userId = this.User.Identity.GetUserId();
if (userId == null || !User.IsInRole("Admin"))
{
return(this.Unauthorized());
}
await uow.ModeratorService.UnblockAd(adId);
return(Ok("Ad is unblocked"));
}
public void Execute(AdDTO request)
{
var ad = Context.Ads.Find(request.Id);
if (ad == null)
{
throw new EntityNotFoundException();
}
if (ad.Title != request.Title)
{
if (Context.Ads.Any(p => p.Title == request.Title))
{
throw new EntityExistException("This Title already exist.");
}
ad.Title = request.Title;
}
if (ad.Body != request.Body)
{
if (Context.Ads.Any(p => p.Body == request.Body))
{
throw new EntityExistException("This Body already exist.");
}
ad.Body = request.Body;
}
ad.Price = request.Price;
ad.IsShipping = request.IsShipping;
Context.SaveChanges();
}
public IActionResult Put(int id, [FromQuery] AdDTO ad)
{
var ads = _context.Ads.Find(id);
if (ads == null)
{
return(NotFound());
}
if (ads.IsDeleted)
{
return(NotFound());
}
ads.Title = ad.Title;
ads.Body = ad.Body;
ads.Price = ad.Price;
ads.IsShipping = ad.IsShipping;
try
{
_context.SaveChanges();
return(NoContent());
}
catch (Exception)
{
return(StatusCode(500, "An error has occured."));
}
}
public async Task <IHttpActionResult> DeleteAd([FromUri] int adId)
{
var authtor = await uow.UserService.GetUserById(User.Identity.GetUserId <int>());
if (authtor == null)
{
return(this.Unauthorized());
}
if (authtor.IsBlocked)
{
return(BadRequest("Your account blocked."));
}
AdDTO ad = await uow.AdService.GetAdById(adId);
if (ad == null)
{
return(NotFound());
}
if (ad.User.Id != authtor.Id)
{
return(BadRequest("It is not your post."));
}
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
await uow.AdService.DeleteAd(adId);
return(Ok("Ad is deleted"));
}
public async Task ManageAd(AdDTO adDTO)
{
var stemmedTitle = await AddToGlobalStrings(adDTO.Title);
var stemmedDescription = await AddToGlobalStrings(adDTO.Description);
var ad = new Ad
{
Title = adDTO.Title,
Description = adDTO.Description,
Company = adDTO.Company,
Owner = await _context.Users.Where(x => x.Id == Guid.Parse(adDTO.Owner.Id)).FirstOrDefaultAsync()
};
var finalGlobalRelations = await ToAdKnn(stemmedTitle, ad, true);
var descriptionGlobalRelations = await ToAdKnn(stemmedDescription, ad, false);
finalGlobalRelations.AddRange(descriptionGlobalRelations);
await _context.AdKnns.AddRangeAsync(finalGlobalRelations);
await _context.Ads.AddAsync(ad);
try
{
await _context.SaveChangesAsync();
}
catch (Exception e)
{
throw e;
}
}
public async Task <ActionResult <Ad> > PostAd([FromForm] AdDTO adDTO)
{
if (!UserExists(adDTO.User))
{
return(NotFound());
}
var maxAds = _options.PublishOptions.MaxAdsByUser;
if (await _context.Users.Where(user => user.Id == adDTO.User).CountAsync() >= maxAds)
{
return(BadRequest());
}
var maxNumber = 0;
if (await _context.Ads.CountAsync() > 0)
{
maxNumber = _context.Ads.Max(x => x.Number);
}
var adId = Guid.NewGuid();
var imageUrl = "";
if (adDTO.Image != null)
{
IImageFileManager imageManager = new ImageFileManager(_options, _cacheController);
imageUrl = imageManager.GenerateURL(adId.ToString(), adDTO.Image.FileName);
try
{
await imageManager.UploadImageAsync(adDTO.Image, imageUrl);
}
catch (Exception)
{
return(Problem("Возникла ошибка при загрузке изображения", null,
StatusCodes.Status500InternalServerError, "Ошибка загрузки изображения"));
}
}
var ad = new Ad
{
Id = adId,
Created = DateTime.Now,
Number = maxNumber + 1,
Rating = new Random().Next(-5, 10),
User = adDTO.User,
Subject = adDTO.Subject,
Content = adDTO.Content ?? adDTO.Subject,
ImageURL = imageUrl
};
await _context.Ads.AddAsync(ad);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetAd), new { id = ad.Id }, ad));
}
public async Task <IActionResult> ChangeStatus(AdDTO ad)
{
var changeCommand = new ChangeAdStatus()
{
Id = ad.Id, Status = ad.Status
};
await DispatcheAsync <ChangeAdStatus>(changeCommand);
return(RedirectToAction("Index", "Admin"));
}
public IActionResult CreateAd([FromBody] AdDTO ad)
{
Ad a = new Ad {
AdType = ad.AdType, Price = ad.Price, CryptoCurrencyAmount = ad.Amount
};
a.AdUid = Guid.NewGuid();
a.Coin = CoinsColl.Find <Coin>(x => x.Symbol == ad.Symbol).FirstOrDefault();
a.Advertiser = Users.Find <User>(x => x.UserName == ad.Advertiser).FirstOrDefault();
Collection.InsertOne(a);
return(Ok(ad));
}
public void Execute(AdDTO request)
{
var ad = Context.Ads.Find(request.Id);
if (ad == null)
{
throw new EntityNotFoundException();
}
ad.IsDeleted = true;
Context.SaveChanges();
}
public async Task AddAd(AdDTO adDTO)
{
var ad = Mapper.Map <AdDTO, Ad>(adDTO);
if (ad.PositionDescription != null)
{
await uow.Ad.Post(ad);
}
else
{
throw new ArgumentException("Wrong data");
}
}
public async Task <IActionResult> EditAd(AdDTO ad)
{
if (!ModelState.IsValid)
{
var categories = await _categoryService.BrowseDTOAsync();
ViewBag.Categories = categories;
return(View(ad));
}
await DispatcheAsync <EditUserAd>(_mapper.Map <EditUserAd>(ad));
return(RedirectToAction("Index", "UserAd"));
}
public async Task EditAd(AdDTO adDTO)
{
var ad = Mapper.Map <AdDTO, Ad>(adDTO);
if (ad.UserId != 0)
{
await uow.Ad.Update(ad);
}
else
{
throw new ArgumentException("Wrong data");
}
}
public void Execute(AdDTO request)
{
Context.Ads.Add(new Domain.Ad
{
Title = request.Title,
Body = request.Body,
Price = request.Price,
IsShipping = request.IsShipping,
CategoryId = request.CategoryId,
UserId = request.UserId
});
Context.SaveChanges();
}
public ActionResult Delete(int id, AdDTO ad)
{
try
{
_deleteAdCommand.Execute(ad);
return(RedirectToAction(nameof(Index)));
}
catch (EntityNotFoundException)
{
return(View());
}
catch (Exception)
{
return(RedirectToAction("index"));
}
}
public async Task <AdDTO> Ad()
{
HttpClient httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("http://localhost:5011/");
httpClient.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage httpResponseMessage = await httpClient.GetAsync("api/ad");
var response = await httpResponseMessage.Content.ReadAsStringAsync();
AdDTO adDTO = JsonConvert.DeserializeObject <AdDTO>(response);
return(adDTO);
}
public async Task <Result <IEnumerable <AdDTO> > > GetAds(string userId)
{
var user = await _context.Users.Where(x => x.Id == Guid.Parse(userId))
.Include(x => x.SkillKnns)
.Include("SkillKnns.GlobalString")
.FirstOrDefaultAsync();
if (user == null)
{
return(Result <IEnumerable <AdDTO> > .CreateFailed(
HttpStatusCode.NotFound, "User not found"));
}
var ads = await _context.Ads
.Where(x => x.Owner != user && !x.UserAds.Select(y => y.User).Contains(user))
.Include(x => x.UserAds)
.Include("UserAds.User")
.Include(x => x.AdKnns)
.Include(x => x.Owner)
.Include("AdKnns.GlobalString")
.ToListAsync();
double distance;
var topDistances = new List <Tuple <double, Ad> >();
foreach (var ad in ads)
{
distance = _knnService.GetDistance(ad, user);
if (topDistances.Count < 10)
{
topDistances.Add(new Tuple <double, Ad>(distance, ad));
}
else
{
var max = topDistances.Max(x => x.Item1);
var maxItem = topDistances.Where(x => x.Item1 == max).FirstOrDefault();
if (max > distance)
{
topDistances[topDistances.IndexOf(maxItem)] = new Tuple <double, Ad>(distance, ad);
}
}
}
var result = topDistances.Select(x => x.Item2);
return(Result <IEnumerable <AdDTO> > .CreateSuccessful(AdDTO.ToAdDTOList(result)));
}
public async Task <IHttpActionResult> AddAd([FromUri] int categoryId)
{
var authtor = await uow.UserService.GetUserById(User.Identity.GetUserId <int>());
if (authtor == null)
{
return(this.Unauthorized());
}
CategoryDTO category = await uow.CategoryService.GetCategoryById(categoryId);
if (category == null)
{
return(NotFound());
}
if (authtor.IsBlocked)
{
return(BadRequest("Your account blocked."));
}
var httpRequest = HttpContext.Current.Request; //get request object
string positionDescriptionCode = httpRequest.Params["Ad"];
string positionDescription = Base64Decode(positionDescriptionCode); //decoding string with html tag
AdDTO ad = new AdDTO
{
PositionName = httpRequest.Params["PositionName"],
Location = httpRequest.Params["Location"],
Company = httpRequest.Params["Company"],
PositionDescription = positionDescription,
CreateDate = DateTime.Now,
UserId = authtor.Id,
CategoryId = 1
};
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
await uow.AdService.AddAd(ad);
return(Content(HttpStatusCode.Created, "Ad is added"));
}
public ActionResult Create(AdDTO ad)
{
if (!ModelState.IsValid)
{
return(View(ad));
}
try
{
_createAdCommand.Execute(ad);
return(RedirectToAction(nameof(Index)));
}
catch (Exception)
{
return(StatusCode(500, "An error has occured."));
}
}
public async Task <IActionResult> AddAd([FromBody] AdDTO ad)
{
try
{
var userId = User.Claims.Where(x => x.Type == "id").FirstOrDefault().Value;
var result = await _adService.AddAd(userId, ad);
if (!result.IsSuccess())
{
return(result.ToErrorResponse());
}
return(Ok(result.Data));
}
catch (Exception)
{
return(BadRequest("Σφάλμα, Επικοινωνήστε με τον διαχειριστή"));
}
}
public async Task <OperationDetails <int> > SaveAd(
string userName,
AdDTO ad,
IFormFileCollection productPhotos)
{
OperationDetails <int> operationDetails = new OperationDetails <int>(false, "", 0);
ApplicationUser user = new ApplicationUser();
if (ad == null)
{
return(new OperationDetails <int>(false, "new Ad can't be null or empty", 0));
}
if (String.IsNullOrEmpty(userName))
{
return(operationDetails);
}
user = await _uof.UserRepository.FindUserByUserName(userName);
if (user == null)
{
return(operationDetails);
}
var newAd = _dataService.TransformingAdDTOToAdEntities(ad);
newAd.ApplicationUser = user;
if (newAd.AdId == 0)
{
newAd.AdStatusId = (int)AdStatuses.Activated;
newAd.IsModerate = true;
operationDetails = await CreateAd(user, newAd, productPhotos);
}
else
{
newAd.AdStatusId = (int)AdStatuses.InProgress;
newAd.IsModerate = false;
operationDetails = await UpdateAd(user, newAd, productPhotos);
}
return(operationDetails);
}
public async Task <IHttpActionResult> EditAd([FromUri] int adId, [FromBody] AdEditViewModel newAd)
{
var authtor = await uow.UserService.GetUserById(User.Identity.GetUserId <int>());
if (authtor == null)
{
return(this.Unauthorized());
}
if (authtor.IsBlocked)
{
return(BadRequest("Your account is blocked."));
}
AdDTO ad = await uow.AdService.GetAdById(adId);
if (ad == null)
{
return(NotFound());
}
if (ad.User.Id != authtor.Id)
{
return(BadRequest("It is not your post."));
}
if (ad.IsBlocked)
{
return(BadRequest("As is blocked."));
}
ad.PositionName = newAd.PositionName;
ad.Location = newAd.Location;
ad.Company = newAd.Company;
ad.PositionDescription = newAd.PositionDescription;
ad.User = null;
ad.Category = null;
await uow.AdService.EditAd(ad);
return(Ok("Ad is edited"));
}
public void CreateAd(AdDTO ad)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <AdDTO, Ad>()
.ForMember(dest => dest.DateAdd, opt => opt.Ignore())
.ForMember(dest => dest.Category, opt => opt.Ignore())
.ForMember(dest => dest.Kind, opt => opt.Ignore())
.ForMember(dest => dest.LocationNew, opt => opt.Ignore())
.ForMember(dest => dest.User, opt => opt.Ignore());
cfg.CreateMap <TagDTO, Tag>();
cfg.CreateMap <ImageDTO, Image>();
});
var mapper = config.CreateMapper();
var adCreate = mapper.Map <AdDTO, Ad>(ad);
DataBase.Ads.Create(adCreate);
DataBase.Save();
}
public AdViewModel PrepearingAdViewModel(IQueryable <CityDTO> citiesDTO,
IQueryable <CityAreaDTO> cityAreasDTO,
IQueryable <ProductTypeDTO> productTypesDTO,
IQueryable <ProductModelsDTO> productModelsDTO,
IQueryable <ProductMemorieDTO> productMemoriesDTO,
IQueryable <ProductColorDTO> productColorsDTO,
IQueryable <ProductStateDTO> productStateDTO,
AdDTO ad)
{
AdViewModel prepearingModel = new AdViewModel {
AdDTO = ad
};
prepearingModel.CityesSelectList = new SelectList(citiesDTO, "Id", "Name");
prepearingModel.CityAreasSelectList = new SelectList(cityAreasDTO, "Id", "Name");
if (ad.Characteristics != null)
{
prepearingModel.ProductModelsSelectList = new SelectList(productModelsDTO.Where(x => x.ProductTypeId == ad.Characteristics.ProductType.ProductTypesId), "Id", "Name");
}
else
{
prepearingModel.ProductModelsSelectList = new SelectList(productModelsDTO, "Id", "Name");
}
prepearingModel.ProductTypesSelectList =
new SelectList(productTypesDTO, "Id", "Name");
prepearingModel.ProductMemoriesSelectList =
new SelectList(productMemoriesDTO, "Id", "StorageSize");
prepearingModel.ProductColorsSelectList =
new SelectList(productColorsDTO, "Id", "Name");
prepearingModel.ProductStatesSelectList =
new SelectList(productStateDTO, "Id", "Name");
return(prepearingModel);
}
public void EditAd(AdDTO ad)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <AdDTO, Ad>()
.ForMember(dest => dest.DateAdd, opt => opt.Ignore())
.ForMember(dest => dest.Category, opt => opt.Ignore())
.ForMember(dest => dest.Kind, opt => opt.Ignore())
.ForMember(dest => dest.LocationNew, opt => opt.Ignore())
.ForMember(dest => dest.User, opt => opt.Ignore())
.ForMember(dest => dest.UserId, opt => opt.Ignore());
cfg.CreateMap <ImageDTO, Image>();
cfg.CreateMap <TagDTO, Tag>()
.ForMember(t => t.InfoReviewTags, p => p.Ignore());
});
var mapper = config.CreateMapper();
var adEdit = mapper.Map <AdDTO, Ad>(ad);
DataBase.Ads.Update(adEdit);
//DataBase.Save();
}
public AdDTO TransformingAdToAdDTO(Ad ad)
{
var adDTO = new AdDTO
{
AdId = ad.AdId,
Title = ad.Title,
Description = ad.Description,
Price = ad.Price,
DateCreated = ad.DateCreated,
DateUpdated = ad.DateUpdated,
Characteristics = ad.Characteristics,
City = ad.City,
Photos = ad.Photos,
AdViews = ad.AdViews,
AdStatusId = ad.AdStatusId,
IsModerate = ad.IsModerate,
Purhcases = ad.Purhcases,
ApplicationUser = ad.ApplicationUser
};
return(adDTO);
}
public Ad TransformingAdDTOToAdEntities(AdDTO ad)
{
Characteristics characteristics = new Characteristics
{
ProductType = new ProductTypes {
ProductTypesId = ad.SelectedProductTypeId
},
ProductModel = new ProductModels {
ProductModelsId = ad.SelectedProductModelId
},
ProductMemorie = new ProductMemories {
ProductMemoriesId = ad.SelectedProductMemoryId
},
ProductColor = new ProductColors {
ProductColorsId = ad.SelectedProductColorId
},
ProductState = new ProductStates {
ProductStatesId = ad.SelectedProductStateId
}
};
Ad Ad = new Ad
{
Title = ad.Title,
Description = ad.Description,
Price = ad.Price,
DateCreated = DateTime.Now,
DateUpdated = DateTime.Now,
City = new City {
CityId = ad.SelectedCityId
},
Characteristics = characteristics,
IsModerate = ad.IsModerate,
AdStatusId = ad.AdStatusId
};
return(Ad);
}
public ActionResult Edit(int id, AdDTO ad)
{
if (!ModelState.IsValid)
{
return(View(ad));
}
try
{
_editAdCommand.Execute(ad);
return(RedirectToAction(nameof(Index)));
}
catch (EntityExistException)
{
TempData["error"] = "Ad already exist!";
}
catch (EntityNotFoundException)
{
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public async Task <Result <IEnumerable <AdDTO> > > GetMyAds(string userId)
{
var user = await _context.Users.Where(x => x.Id == Guid.Parse(userId))
.Include(x => x.SkillKnns)
.Include("SkillKnns.GlobalString")
.FirstOrDefaultAsync();
if (user == null)
{
return(Result <IEnumerable <AdDTO> > .CreateFailed(
HttpStatusCode.NotFound, "User not found"));
}
var ads = await _context.Ads
.Where(x => x.Owner == user)
.Include(x => x.UserAds)
.Include("UserAds.User")
.Include(x => x.AdKnns)
.Include(x => x.Owner)
.Include("AdKnns.GlobalString")
.ToListAsync();
return(Result <IEnumerable <AdDTO> > .CreateSuccessful(AdDTO.ToAdDTOList(ads)));
}
public async Task <Result <bool> > AddAd(string userId, AdDTO adDTO)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(Result <bool> .CreateFailed(
HttpStatusCode.NotFound, "User not found"));
}
await _knnService.ManageAd(adDTO);
try
{
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(Result <bool> .CreateFailed(
HttpStatusCode.InternalServerError, "Cound't add ad"));
}
return(Result <bool> .CreateSuccessful(true));
}
