private void AddRate(RecipeDto recipe)
{
var rates = _ratesService.GetRates(recipe.Id);
if (_loggedUser != null)
{
var loggedUserRate = rates.SingleOrDefault(x => x.User.Id == _loggedUser.Id);
if (loggedUserRate != null)
{
Console.WriteLine($"Your rate: {loggedUserRate.Score}");
}
else
{
var choice = _getDataFromUser.GetData("Do you want to rate this recipe? Y/N");
if (choice.ToUpper() == "Y")
{
var score = _getDataFromUser.GetNumber("Your rate (0-10): ", 0, 10);
var rate = new RateDto
{
Id = Guid.NewGuid(),
Score = score,
User = _loggedUser,
Recipe = recipe
};
var result = _ratesService.AddRate(rate);
ShowResult(result);
UpdateLoggedUser();
}
;
}
}
}
public IEnumerable <RateDto> CurrentRates()
{
var currencyDoc = new XmlDocument();
currencyDoc.Load(_url);
var nodes = currencyDoc.SelectNodes("//*[@currency]");
if (nodes == null)
{
yield break;
}
foreach (XmlNode node in nodes)
{
if (node.Attributes == null)
{
continue;
}
var rate = new RateDto
{
Currency = node.Attributes["currency"].Value,
Value = double.Parse(node.Attributes["rate"].Value, NumberStyles.Any, new CultureInfo("en-Us"))
};
yield return(rate);
}
}
public int GetRateIdAfterAdd(RateDto rateDto)
{
if (rateDto == null)
{
GenerateFaultException("AddRate", "ArgumentException");
}
var parameters = new List <Parameter>();
parameters.Add(new Parameter {
Type = DbType.DateTime, Name = "@DateRate", Value = rateDto.DateRate
});
parameters.Add(new Parameter {
Type = DbType.Decimal, Name = "@RateAmount", Value = rateDto.Amount
});
parameters.Add(new Parameter {
Type = DbType.Int32, Name = "@UserId", Value = rateDto.UserId
});
var connection = new Connection <RateDto>();
try
{
return(connection.GetConnectionAddRate(CommandType.StoredProcedure, "AddRate", parameters));
}
catch (SqlException sqlEx)
{
var exception = new CustomException();
exception.Title = "AddRate";
log.Error(sqlEx.Message);
throw new FaultException <CustomException>(exception, sqlEx.Message);
}
}
public RateDto AddRate(RateDto rateDto)
{
var rate = _mapper.Map <Rate>(rateDto);
var addedRate = _ratesRepository.AddRate(rate);
return(_mapper.Map <RateDto>(addedRate));
}
public async Task <IActionResult> Rate(RateDto rateDto)
{
var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (!(await _postService.Any(rateDto.PostId)))
{
return(new ObjectActionResult(success: false, statusCode: HttpStatusCode.NotFound, data: null));
}
if (await _rateService.Any(rateDto.PostId, userId))
{
var _rating = _rateService.GetRate(rateDto.PostId, userId);
var rating = _mapper.Map <Rating>(rateDto);
rating.Id = _rating.Id;
rating.UserId = userId;
var rate = _rateService.Update(rating);
return(new ObjectActionResult(success: true, statusCode: HttpStatusCode.OK, data: rate));
}
else
{
var rating = _mapper.Map <Rating>(rateDto);
rating.UserId = userId;
var rate = _rateService.Save(rating);
return(new ObjectActionResult(success: true, statusCode: HttpStatusCode.Created, data: rate));
}
}
public async Task <IActionResult> Rate([FromRoute] string id, [FromBody] RateDto rateDto)
{
try
{
var mongodb = GetMongoCollection();
var document = await mongodb.Find(g => g.Id == ObjectId.Parse(id)).FirstOrDefaultAsync();
document.Ratings.Add(new GameRating
{
Rating = rateDto.Rating,
UserName = rateDto.UserName,
Reason = rateDto.Reason,
AddedDate = DateTime.Now
});
var sumOfRatings = document.Ratings.Sum(r => r.Rating);
var count = document.Ratings.Count;
document.AverageRating = Math.Round((double)sumOfRatings / count, 2);
await mongodb.ReplaceOneAsync(g => g.Id == ObjectId.Parse(id), document);
return(Ok(MapToDto(document)));
}
catch (Exception ex)
{
return(BadRequest());
}
}
public async Task <ActionResult> Rate(Guid id, RateDto dto)
{
_rateDtoValidator.Validate(dto).ThrowIfInvalid();
await _service.RateAsync(id, dto);
return(Ok());
}
public decimal GenerateAmountByType(RateDto rate, int type)
{
// Calcula o periodo de acordo com o tipo
return(type == 0 ? rate.DailyAmount :
type == 1 ? rate.OvernightAmount :
type == 2 ? rate.PeriodAmount : rate.DailyAmount);
}
public async Task <RateDto> Update(RateDto dto)
{
var rate = await this.GetById(dto.Id);
RateMapper.MapUpdate(rate, dto);
await this.dbContext.SaveChangesAsync();
return(RateDtoMapper.Map(rate));
}
public async Task <RateDto> Create(RateDto dto)
{
var rate = RateMapper.Map(dto);
await dbContext.Rates.AddAsync(rate);
await dbContext.SaveChangesAsync();
return(RateDtoMapper.Map(rate));
}
public IValitResult Validate(RateDto dto, IValitStrategy strategy = null)
=> ValitRules <RateDto>
.Create()
.WithStrategy(s => s.Complete)
.Ensure(r => r.Value, _ => _
.IsPositive()
.IsLessThanOrEqualTo(5))
.For(dto)
.Validate();
public static Rate DtoToEntity(this RateDto rateDto)
{
return(new Rate()
{
DailyAmount = rateDto.DailyAmount,
OvernightAmount = rateDto.OvernightAmount,
PeriodAmount = rateDto.PeriodAmount
});
}
public static void MapUpdate(Rate rate, RateDto dto)
{
rate.Name = dto.Name;
rate.Call = CallMapper.Map(dto.Call);
rate.Sms = SmsMapper.Map(dto.Sms);
rate.Internet = InternetMapper.Map(dto.Internet);
rate.Roaming = RoamingMapper.Map(dto.Roaming);
rate.HomeInternet = HomeInternetMapper.Map(dto.HomeInternet);
}
public bool IsCorrectRate(RateDto rateDto)
{
return(rateDto != null
&& !IsBlankBoardType(rateDto.boardType)
&& IsCorrectRateType(rateDto.rateType)
&& IsCorrectPrice(rateDto.value));
}
public IActionResult Update([FromBody] RateDto rate)
{
if (_rateAppService.Update(rate))
{
return(Ok());
}
else
{
return(BadRequest());
}
}
public Rate ToRate(RateDto rateDto)
{
var Rate = new Rate
{
RateId = rateDto.RateId,
DateRate = rateDto.DateRate,
Amount = rateDto.Amount,
UserId = rateDto.UserId
};
return(Rate);
}
public RateDto ToRateDto(Rate rate)
{
var rateDto = new RateDto
{
RateId = rate.RateId,
Amount = rate.Amount,
DateRate = rate.DateRate,
UserId = rate.UserId
};
return(rateDto);
}
public static Rate Map(RateDto dto)
{
return(new Rate
{
Id = dto.Id,
Name = dto.Name,
Call = CallMapper.Map(dto.Call),
Sms = SmsMapper.Map(dto.Sms),
Internet = InternetMapper.Map(dto.Internet),
Roaming = RoamingMapper.Map(dto.Roaming),
HomeInternet = HomeInternetMapper.Map(dto.HomeInternet),
});
}
public async Task <IActionResult> Create(RateDto rate)
{
if (rate.Id == 0)
{
await this.rateService.Create(rate);
}
else
{
await this.rateService.Update(rate);
}
return(RedirectToAction("Index"));
}
public bool Update(RateDto rateDto)
{
try
{
_context.Rate.Update(rateDto.DtoToEntity());
_context.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
public async Task <IActionResult> SetRate(RateDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _eventService.SetRate(model.UserId, model.EventId, model.Rate);
if (result.Successed)
{
return(Ok());
}
return(BadRequest());
}
public object PostCalculateRates([FromBody] RateDto rate)
{
object response = string.Empty;
try
{
response = rateService.Calculate(rate);
}
catch (Exception ex)
{
response = ex.ToString();
}
return(response);
}
public async Task Rate(string id, RateDto dto)
{
User user = await _sessionService.GetUser();
Validate("rate", user);
Response response = await _responseRepository.GetById(id);
if (response == null)
{
_logger.LogWarning($"There is no response with id {id}");
throw HttpError.NotFound($"There is no response with id {id}");
}
await _likeRepository.GiveLike(user, response, dto.IsLike);
}
public ConversionRateTest()
{
var faker = new Faker();
rateDto = new RateDto
{
ValueOrigin = faker.Random.Double(1, 10000),
CurrencyOrigin = "USD",
CurrencyDestination = "BRL",
FormatMsg = faker.Random.Int(0, 1).ToString(),
ApiKey = faker.Random.Hash().ToString()
};
rateServiceMock = new Mock <IRateService>();
conversionRate = new ConversionRate(rateServiceMock.Object);
}
private decimal GetRateFinalPrice(RateDto rate, int nights)
{
if (!Enum.TryParse <AvailabilityRateType>(rate.rateType, out var rateType))
{
return(0);
}
switch (rateType)
{
case AvailabilityRateType.PerNight:
return(rate.value.Value * nights);
case AvailabilityRateType.Stay:
return(rate.value.Value);
}
return(0);
}
public bool Delete(RateDto rateDto)
{
try
{
if (rateDto != null)
{
_context.Rate.Remove(rateDto.DtoToEntity());
_context.SaveChanges();
return(true);
}
return(false);
}
catch
{
return(false);
}
}
public HttpResponseMessage MakeRate(RateDto rateDto)
{
try
{
if (ModelState.IsValid)
{
var CurrentUser = context.UserMasters.FirstOrDefault(u => u.UserName == RequestContext.Principal.Identity.Name);
var Driver = context.UserMasters.Find(rateDto.DriverId);
if (Driver == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "this driver was not found"));
}
var Reservation = context.Reservations.FirstOrDefault(r => r.TravellerId == CurrentUser.UserID && context.trips.FirstOrDefault(t => t.ID == r.ID).DriverId == Driver.UserID);
if (Reservation == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "you can't rate this car owner because you didn't travel with him before"));
}
var RecentlyRated = context.Ratings.FirstOrDefault(r => r.TravellerId == CurrentUser.UserID && r.DriverId == Driver.UserID);
if (RecentlyRated != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "you have recently rated this user"));
}
Rating rate = new Rating()
{
DriverId = rateDto.DriverId,
TravellerId = CurrentUser.UserID,
RateValue = rateDto.RateValue,
};
Driver.DriverTotalRate = Driver.CalcTotalRate();
context.Ratings.Add(rate);
context.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "rate was made successfully"));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "you didnt complete some required fields"));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public async Task <double> Rate([FromBody] RateDto rate)
{
_context.Rating.Add(new Rating()
{
PostId = rate.PostId,
Score = rate.Score
});
await _context.SaveChangesAsync();
var post = await _context.Post.FirstOrDefaultAsync(f => f.Id == rate.PostId);
var avg = await _context.Rating.Where(w => w.PostId == rate.PostId).Select(s => s.Score).ToListAsync();
post.Score = avg.Average();
await _context.SaveChangesAsync();
return(post.Score);
}
public async Task <ApiResponse> addRateOfProduct(RateDto dto)
{
try
{
if (dto.Rating != 0)
{
var rating = _mapper.Map <Rate>(dto);
await _rateService.AddAsync(rating);
return(new ApiResponse("Success", rating, 200));
}
return(new ApiResponse("Error"));
}catch (Exception ex)
{
return(new ApiResponse($"Error : {ex}", ex, 400));
}
}
public bool Create(RateDto rateDto)
{
try
{
_context.Rates.Add(new Rate()
{
Description = rateDto.Description,
DailyAmount = rateDto.DailyAmount,
HourAmount = rateDto.HourAmount,
OvernightAmount = rateDto.OvernightAmount
});
_context.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
