public ActionResult Details(int id, RateViewModel collection)
{
try
{
if (id > 0)
{
collection.UpdaterId = LogedInAdmin.Id;
_rateService.Delete(_mapper.Map <Rate>(collection));
return(RedirectToAction("Index"));
}
ModelState.AddModelError(string.Empty, GeneralMessages.EmptyId);
return(View(collection));
}
catch (Exception ex)
{
_logger.Error(ex);
if (ex.InnerException != null && ex.InnerException.Source.Equals(GeneralMessages.ExceptionSource))
{
ModelState.AddModelError(string.Empty, ex.Message);
}
else
{
ModelState.AddModelError(string.Empty, GeneralMessages.UnexpectedError);
}
return(View(collection));
}
}
public void RateAlbum(RateViewModel rate)
{
if (rate.UserId == null)
{
throw new Exception("User can not be null!");
}
if (rate.Rating < 1 || rate.Rating > 10)
{
throw new Exception("Rating has to be between 1 and 10!");
}
var currentRate = _db.Ratings.SingleOrDefault(r => r.AlbumId == rate.AlbumId && r.UserId == rate.UserId);
if (currentRate == null)
{
var ratingToDb = new Rating()
{
UserId = rate.UserId,
AlbumId = rate.AlbumId,
Rate = rate.Rating,
DateAdded = DateTime.Now
};
_db.Ratings.Add(ratingToDb);
}
else
{
currentRate.Rate = rate.Rating;
currentRate.DateAdded = DateTime.Now;
}
_db.SaveChanges();
}
public async Task <bool> Do_CalificarDesafio(int profId,
int desafioId, RateViewModel model)
{
if (!await _data.Exist_Desafio(desafioId))
{
return(false);
}
var desafio = await _data.Find_Desafio(desafioId);
var profesor = await _data.Find_Profesor(desafio.ProfesorId);
if (profId != profesor.Id)
{
_data.Do_PushNotification(
NotificationType.NotificationDesafioCalificado,
profesor.UsuarioId, new Dictionary <string, string>()
{
["IdDesafio"] = $"{desafioId}",
["NombreDesafio"] = $"{desafio.Nombre}"
});
}
await _data.Calificar_Desafio(desafioId, profId,
model.Rate);
return(await _data.SaveAllAsync());
}
public ActionResult AddRate(RateViewModel rate)
{
if (ModelState.IsValid)
{
using (var repo = RepositoryFactory.GetCurrencyRateRepository())
{
repo.AddOrUpdate(new CurrencyRate
{
CurrencyId = rate.FromId,
TargetCurrencyId = rate.ToId,
CrossCourse = rate.Value,
Date = rate.Date
});
repo.SaveChanges();
return(RedirectToAction("Rates"));
}
}
using (var repo = RepositoryFactory.GetCurrencyRepository())
{
rate.From = repo.GetAll();
rate.To = repo.GetAll();
}
return(View("AddRate", rate));
}
public async Task AddRateAsync(RateViewModel model)
{
Rating rating = null;
if (this.AlreadyRated(model.UserId, model.ProductId))
{
rating = this.repository.All()
.Where(a => a.UserId == model.UserId && a.ProductId == model.ProductId)
.FirstOrDefault();
rating.Grade = (Grade)model.Grade;
rating.Description = model.Description;
}
else
{
rating = new Rating
{
UserId = model.UserId,
ProductId = model.ProductId,
Description = model.Description,
Grade = (Grade)model.Grade,
};
await this.repository.AddAsync(rating);
}
await this.repository.SaveChangesAsync();
}
/// <summary>
/// Metodo calificar libro
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public int RateLibro(RateViewModel model)
{
try
{
var libro = _db.libro
.SingleOrDefault(r => r.Codigo == model.LibroCodigo);
if (libro == null)
{
return(404);
}
Calificacion cal = new Calificacion
{
LibroCodigo = model.LibroCodigo,
Rate = model.Rate
};
if (cal.Rate == 0)
{
return(500);
}
_db.calificacion.Add(cal);
_db.SaveChanges();
return(201);
}
catch (Exception)
{
return(500);
}
}
public async Task AddRate(RateViewModel model, long userId)
{
var user = await Uow.UserRepository.GetWithMovies(userId);
var rate = user.Movies.FirstOrDefault(x => x.MovieId == model.MovieId);
var movie = await Uow.MovieRepository.Get(model.MovieId);
if (movie == null)
{
throw new ArgumentException($"Movie with id {model.MovieId} not found");
}
if (rate == null)
{
await Uow.UserMoviesRepository.Add(new UserMovie { UserId = userId, MovieId = model.MovieId, Rate = model.Value });
movie.RatesCount++;
movie.RatesSum += model.Value;
}
else
{
movie.RatesSum = movie.RatesSum - (int)rate.Rate + model.Value;
rate.Rate = model.Value;
}
await Uow.SaveChangesAsync();
}
public JsonResult Uploader(IList <IFormFile> files)
{
List <RateViewModel> csv_data = new List <RateViewModel>();
foreach (IFormFile source in files)
{
using (StreamReader csv_reader = new StreamReader(source.OpenReadStream()))
{
csv_reader.ReadLine();
while (csv_reader.Peek() != -1)
{
string csv_data_raw = csv_reader.ReadLine();
if (!string.IsNullOrEmpty(csv_data_raw.Trim()))
{
RateViewModel rate_view = new RateViewModel();
string[] csv_arr = csv_data_raw.Split(',');
rate_view.rate_date = csv_arr[0];
rate_view.country = csv_arr[1];
rate_view.currency = csv_arr[2];
rate_view.amount = decimal.Parse(csv_arr[3]);
csv_data.Add(rate_view);
}
}
}
}
var json = JsonSerializer.Serialize(csv_data);
return(Json(json));
}
public ActionResult Index(RateViewModel collection)
{
long totalCount;
var request = new FilteredModel <Rate>
{
PageIndex = collection.ThisPageIndex,
Order = collection.PageOrder,
OrderBy = collection.PageOrderBy
};
var offset = (request.PageIndex - 1) * request.PageSize;
var result = _mapper.Map <IList <RateViewModel> >(_rateService.GetPaging(_mapper.Map <Rate>(collection), out totalCount, request.OrderBy, request.Order, offset, request.PageSize));
if (!result.Any() && totalCount > 0 && request.PageIndex > 1)
{
request.PageIndex = (int)(totalCount / request.PageSize);
if (totalCount % request.PageSize > 0)
{
request.PageIndex++;
}
result = _mapper.Map <IList <RateViewModel> >(_rateService.GetPaging(_mapper.Map <Rate>(collection), out totalCount, request.OrderBy, request.Order, offset, request.PageSize));
}
ViewBag.OnePageOfEntries = new StaticPagedList <RateViewModel>(result, request.PageIndex, request.PageSize, (int)totalCount);
ViewBag.SearchModel = collection;
return(View());
}
public async Task <IActionResult> Rate([FromBody] RateViewModel model)
{
var user = await userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
return(Unauthorized());
}
if (model == null)
{
return(NotFound());
}
UserRate userRate = await userRateRep.GetUserRateByUserAndTitleAsync(user.Id, model.TitleId);
if (userRate == null || userRate?.Id == 0)
{
await userRateRep.AddAsync(user.Id, model.TitleId, model.Score);
}
else
{
userRate.Score = model.Score;
await userRateRep.UpdateAsync(userRate);
}
return(NoContent());
}
public async Task <IActionResult> AddRate([FromBody] RateViewModel model)
{
long userId = Convert.ToInt64(User.FindFirst(ClaimTypes.Name).Value);
await service.AddRate(model, userId);
return(Ok());
}
public RateViewModel GetEmptyData()
{
RateViewModel Data = new RateViewModel();
Data.Name = string.Empty;
Data.Value = 0;
return(Data);
}
public Rate MapToModel(RateViewModel viewModel)
{
Rate model = new Rate();
PropertyCopier <RateViewModel, Rate> .Copy(viewModel, model);
model.Value = (double)viewModel.Value;
return(model);
}
public RateViewModel MapToViewModel(Rate model)
{
RateViewModel viewModel = new RateViewModel();
PropertyCopier <Rate, RateViewModel> .Copy(model, viewModel);
viewModel.Value = model.Value;
return(viewModel);
}
public covid()
{
RateViewModel viewModel;
InitializeComponent();
///////////////////////////RateInfo///////////////////
viewModel = new RateViewModel();
// установка контекста данных
this.BindingContext = viewModel;
}
public async Task <ActionResult> Rate([Bind("MovieId, Value")] RateViewModel rate)
{
await _movieService.RateMovie(rate.MovieId, rate.Value);
return(Json(new
{
Status = true,
Message = "Succesfully saved"
}));
}
public IActionResult RateBook(RateViewModel rateVM)
{
if (string.IsNullOrEmpty(rateVM.UserId) && string.IsNullOrEmpty(rateVM.RatedEssenceId) && (rateVM.Value < 1 || rateVM.Value > 5))
{
return(RedirectToAction("Error"));
}
BookDTO bookTORate = _bookService.Get(rateVM.RatedEssenceId);
if (bookTORate == null)
{
return(RedirectToAction("Error"));
}
RateDTO yourRate = new RateDTO {
BookId = rateVM.RatedEssenceId,
UserId = rateVM.UserId,
Value = rateVM.Value
};
List <RateDTO> allRates = _rateService.GetAll().ToList();
if (allRates != null)
{
bool isFinded = false;
foreach (var r in allRates)
{
if (r.BookId == rateVM.RatedEssenceId && r.UserId == rateVM.UserId)
{
isFinded = true;
yourRate.Id = r.Id;
bookTORate.Rate += (yourRate.Value - r.Value) / bookTORate.RatesAmount;
_rateService.Update(yourRate);
_bookService.Update(bookTORate);
break;
}
}
if (!isFinded)
{
uint amount = bookTORate.RatesAmount;
bookTORate.RatesAmount++;
bookTORate.Rate = (bookTORate.Rate * amount + yourRate.Value) / bookTORate.RatesAmount;
_bookService.Update(bookTORate);
_rateService.Add(yourRate);
}
}
else
{
uint amount = bookTORate.RatesAmount;
bookTORate.RatesAmount++;
bookTORate.Rate = (bookTORate.Rate * amount + yourRate.Value) / bookTORate.RatesAmount;
_bookService.Update(bookTORate);
_rateService.Add(yourRate);
}
return(RedirectToAction("GetBookInfo", "Home", new { id = bookTORate.Id }));
}
public async Task <IActionResult> RateBook(RateViewModel rateVM)
{
if (string.IsNullOrEmpty(rateVM.UserId) || string.IsNullOrEmpty(rateVM.RatedEssenceId) || rateVM.Value < 1 || rateVM.Value > 5)
{
return(RedirectToAction("Error"));
}
string postData = JsonConvert.SerializeObject(rateVM);
await _client.PostData("rates/rateBook", postData);
return(RedirectToAction("GetBookInfo", "Home", new { id = rateVM.RatedEssenceId }));
}
private void LoadViewModel()
{
reader = new Reader();
viewModel = new RateViewModel(this);
viewModel.Rate = reader.Rates.FirstOrDefault();
viewModel.Series = new ObservableCollection<RateTimeSeries>();
viewModel.Series.Add( new RateTimeSeries() { Ask = viewModel.Rate.Ask, Date = viewModel.Rate.Date });
rates = reader.Rates;
DataContext = viewModel;
}
public RatePage(RatingHairdresserDto ratingHairdresser)
{
InitializeComponent();
model = new RateViewModel();
model.HairdresserId = ratingHairdresser.HairdresserId;
model.FirstName = ratingHairdresser.FirstName;
model.LastName = ratingHairdresser.LastName;
model.Email = ratingHairdresser.Email;
model.Phone = ratingHairdresser.Phone;
model.Image = ratingHairdresser.Image;
BindingContext = model;
}
public async Task <IActionResult> Rate(RateViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
string userId = this.manager.GetUserId(this.User);
model.UserId = userId;
await this.service.AddRateAsync(model);
return(this.RedirectToAction("AllRating", new { productId = model.ProductId }));
}
public ViewComponentResult Submit([FromBody] RateViewModel rateViewModel)
{
var sourceRate = _mapper.Map <Rate>(rateViewModel);
var username = HttpContext.User.Identity.Name;
var user = _wrapperBusiness.Account.GetUserByUsername(username);
var currentRate = _wrapperBusiness.Rate.GetRateOfUserByGameId(sourceRate.GameId, username);
currentRate = (currentRate == null) ?
_wrapperBusiness.Rate.Create(sourceRate, user) :
_wrapperBusiness.Rate.Update(currentRate, sourceRate);
_wrapperBusiness.Score.UpdateScoreByGameId(currentRate.GameId);
return(ViewComponent("Score", Convert.ToInt32(rateViewModel.GameId)));
}
public ActionResult Rate(int ID)
{
var station = this._stationRepo.GetStationByID(ID);
var viewModel = new RateViewModel()
{
Station = station,
RegularGas = station.FuelPrices.SingleOrDefault(p => p.Fuel.FuelType == FuelType.Gas && p.Fuel.FuelGrade == FuelGrade.Regular)?.Price.PriceValue ?? 0,
PremiumGas = station.FuelPrices.SingleOrDefault(p => p.Fuel.FuelType == FuelType.Gas && p.Fuel.FuelGrade == FuelGrade.Premium)?.Price.PriceValue ?? 0,
RegularDiesel = station.FuelPrices.SingleOrDefault(p => p.Fuel.FuelType == FuelType.Diesel && p.Fuel.FuelGrade == FuelGrade.Regular)?.Price.PriceValue ?? 0,
PremiumDiesel = station.FuelPrices.SingleOrDefault(p => p.Fuel.FuelType == FuelType.Diesel && p.Fuel.FuelGrade == FuelGrade.Premium)?.Price.PriceValue ?? 0
};
return(View(viewModel));
}
public SpotTileViewModel(
Func<SpotTileViewModel, IViewModelController> controllerFactory,
IRegionManager regionManager,
IMessageBoxService messageBoxService)
: base(regionManager, messageBoxService)
{
OkCommand = new ReactiveCommand<object, object>(x => IsValid() && IsEnabled);
controller = controllerFactory(this);
this.AddDisposable(controller);
controller.Start();
RateViewModel = new RateViewModel();
base.PlaceItem();
}
public IActionResult RateMovie([FromBody] RateViewModel rateViewModel)
{
try
{
votingService.RateMovie(rateViewModel);
}
catch (Exception)
{
return(BadRequest(new ErrorDTO {
Error = true,
ErrorMessage = "Unknown error."
}));
}
return(Ok());
}
public IActionResult Rate([FromBody] RateViewModel model)
{
try
{
var winner = _movieRepository.Get(model.WinnerId);
var loser = _movieRepository.Get(model.LoserId);
var results = _ratingService.Rate(winner, loser);
_movieRepository.Update(results.winner);
_movieRepository.Update(results.loser);
return(Ok(model));
}
catch (System.Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IActionResult> RateByQTR()
{
IQueryable <string> genreQuery = from p in _context.CompleteRates
group p by new
{
WAVE = p.WAVE,
QTR = p.QTR
} into g
select g.Key.QTR;
var appealsrates = from rate in _context.CompleteRates.Where(x => x.TYPE == "APPEALS") orderby rate.SERVICE_AREA select rate;
var complaintsrates = from rate in _context.CompleteRates.Where(x => x.TYPE == "COMPLAINTS") orderby rate.SERVICE_AREA select rate;
var typerates = from c in appealsrates
from p in complaintsrates
where c.QTR.Equals(p.QTR) && c.SERVICE_AREA.Equals(p.SERVICE_AREA)
select new CompleteRate {
ID = c.TOTAL, WAVE = c.COMPLETE, QTR = c.QTR, SERVICE_AREA = c.SERVICE_AREA, TOTAL = p.TOTAL, COMPLETE = p.COMPLETE
};
var appealsquarterrates = from p in appealsrates group p by p.QTR into g select new CompleteRate {
QTR = g.Key, TOTAL = g.Sum(p => p.TOTAL), COMPLETE = g.Sum(p => p.COMPLETE)
};
var complaintsquarterrates = from p in complaintsrates group p by p.QTR into g select new CompleteRate {
QTR = g.Key, TOTAL = g.Sum(p => p.TOTAL), COMPLETE = g.Sum(p => p.COMPLETE)
};
var quarterrates = from c in appealsquarterrates
from p in complaintsquarterrates
where c.QTR.Equals(p.QTR)
select new CompleteRate {
ID = c.TOTAL, WAVE = c.COMPLETE, QTR = c.QTR, TOTAL = p.TOTAL, COMPLETE = p.COMPLETE
};
var rateVM = new RateViewModel();
rateVM.quarters = new SelectList(await genreQuery.Distinct().ToListAsync());
rateVM.typeRates = await typerates.ToListAsync();
rateVM.quarterRates = await quarterrates.ToListAsync();
return(View(rateVM));
}
public static Response Create(RateViewModel model)
{
var response = ResponseFactory.Success(ResponseCode.SuccessEntityCreated);
if (model == null)
{
return(ResponseFactory.Error(ResponseCode.ErrorInvalidInput));
}
var rate = model.CopyTo();
var createdRate = Create(rate);
if (createdRate == null)
{
response = ResponseFactory.Error(ResponseCode.ErrorCreatingEntity);
}
return(response);
}
public ActionResult Rate(RateViewModel model, string submit)
{
if (submit != null)
{
model.Value = int.Parse(submit);
model.UserId = User.Identity.GetUserId();
model.OrganizationId = model.OrganizationId;
var newRating = Mapper.Map<Rating>(model);
this.ratings.AddNew(newRating);
return this.RedirectToAction("Details", "Organizations", new { area = "", id = model.OrganizationId});
}
return new HttpStatusCodeResult(404);
}
public ActionResult Rate(RateViewModel model, string submit)
{
if (submit != null)
{
model.Value = int.Parse(submit);
model.UserId = User.Identity.GetUserId();
model.OrganizationId = model.OrganizationId;
var newRating = Mapper.Map <Rating>(model);
this.ratings.AddNew(newRating);
return(this.RedirectToAction("Details", "Organizations", new { area = "", id = model.OrganizationId }));
}
return(new HttpStatusCodeResult(404));
}
public async Task AddRateAsyncTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Rating>(dbContext);
var service = new RatesService(repository);
var newRating = new RateViewModel
{
Description = "Test",
Grade = (int)Grade.VeryGood,
ProductId = 1,
UserId = "Test",
};
await service.AddRateAsync(newRating);
}
public IActionResult Gify(GifyDates gifyDates)
{
RateViewModel rateViewModel = new RateViewModel();
var firstValue = _ratesService.GetRateByDate(DateTime.Parse(gifyDates.FistDate), "RUB");
var secondValue = _ratesService.GetRateByDate(DateTime.Parse(gifyDates.SecondDate), "RUB");
if (secondValue > firstValue)
{
rateViewModel.IsBigger = true;
rateViewModel.Url = _gifsService.GetGifs("l1AsxS5F4Au3gelck");
}
else
{
rateViewModel.IsBigger = false;
rateViewModel.Url = _gifsService.GetGifs("7x90dc0KEjRNC");
}
return(View(rateViewModel));
}
public ActionResult Edit(RateViewModel model)
{
if (SessionVars.UserName.IsNullOrWhiteSpace())
{
return(RedirectToAction("Login", new { controller = "Account" }));
}
if (ModelState.IsValid)
{
model.UpdatedBy = SessionVars.UserName;
model.SaveViewModel();
TempData["Success"] = "Program updated successfully!";
return(RedirectToAction("Edit", new { controller = "Rate", id = model.Id }));
}
//if selected vendors is null initialize it
model.SelectedVendors = model.SelectedVendors ?? new List <int>();
model.SetDropdowns();
return(View(model));
}
public RateController(CompositionContainer container, IShellService shellService, RateViewModel rateViewModel)
{
this.container = container;
this.shellService = shellService;
this.rateViewModel = rateViewModel;
}
