public async Task <ResultVm <BrandVm> > Handle(Query request, CancellationToken cancellationToken)
{
var brand = await _context.Brands
.FirstOrDefaultAsync(x => x.Id == request.Id);
return(ResultVm <BrandVm> .Success(_mapper.Map <Domain.Brand, BrandVm>(brand)));
}
public JsonResult EvaluateAnswers(List <Question> questions, int StudentId, int CourseId)
{
ResultVm resultVm = new ResultVm();
var Marks = 0;
foreach (var question in questions)
{
resultVm.ExamsId = question.ExamsId;
foreach (var questionAnswer in question.QuestionAnswers)
{
var data = examManager.GetQuestionbyOrder(question);
//var answer = examManager.GetQuestionAnswer(data);
foreach (var dataAnswers in data.QuestionAnswers)
{
if (questionAnswer.OptionText == dataAnswers.OptionText && dataAnswers.IsAnswer)
{
Marks = Marks + Convert.ToInt32(data.Marks);
}
}
}
}
resultVm.StudentId = StudentId;
resultVm.CourseId = CourseId;
var result = Mapper.Map <Result>(resultVm);
result.Students.Add(examManager.GetStudentById(StudentId));
result.Courses.Add(examManager.GetCourseById(CourseId));
result.ObtainedMarks = Marks;
bool isSaved = examManager.SaveResult(result);
return(Json(JsonRequestBehavior.AllowGet));
}
public static ResultVm <T> FromSuccessObject <T>(this ResultVm <T> rvm, T obj)
{
rvm.Result = Constants.SUCCESS_RESULT;
rvm.Data = obj;
return(rvm);
}
public async Task <ResultVm <Unit> > Handle(Command request, CancellationToken cancellationToken)
{
var product = await _context.Products.Include(p => p.Pictures)
.FirstOrDefaultAsync(x => x.Id == request.proId);
if (product == null)
{
return(null);
}
var photo = product.Pictures.FirstOrDefault(x => x.Id == request.Id);
if (photo == null)
{
return(null);
}
var currentMain = product.Pictures.FirstOrDefault(x => x.IsMain);
if (currentMain != null)
{
currentMain.IsMain = false;
}
photo.IsMain = true;
var success = await _context.SaveChangesAsync() > 0;
if (success)
{
return(ResultVm <Unit> .Success(Unit.Value));
}
return(ResultVm <Unit> .Failure("Problem setting main photo"));
}
public async Task <ResultVm <Picture> > Handle(Command request, CancellationToken cancellationToken)
{
var product = await _context.Products.Include(p => p.Pictures)
.FirstOrDefaultAsync(x => x.Id == request.productId);
if (product == null)
{
return(null);
}
var photoUploadResult = await _photoAccessor.AddPhoto(request.File);
var photo = new Picture {
Url = photoUploadResult.Url,
Id = photoUploadResult.PublicId
};
if (!product.Pictures.Any(x => x.IsMain))
{
photo.IsMain = true;
}
product.Pictures.Add(photo);
var result = await _context.SaveChangesAsync() > 0;
if (result)
{
return(ResultVm <Picture> .Success(photo));
}
return(ResultVm <Picture> .Failure("Problem with adding Picture"));
}
public async Task <ResultVm <Unit> > Handle(Command request, CancellationToken cancellationToken)
{
var product = await _context.Products.FindAsync(request.Product.Id);
if (product == null)
{
return(null);
}
product.Name = request.Product.Name;
product.Price = request.Product.Price;
product.Description = request.Product.Description;
product.BrandId = request.Product.BrandId;
product.UpdatedDate = DateTime.Now;
var result = await _context.SaveChangesAsync() > 0;
if (!result)
{
return(ResultVm <Unit> .Failure("Failed to update Product"));
}
return(ResultVm <Unit> .Success(Unit.Value));
}
public static ResultVm <int> FromSuccessInt(this ResultVm <int> rvm, int val)
{
rvm.Result = Constants.SUCCESS_RESULT;
rvm.Data = val;
return(rvm);
}
public async Task <ResultVm <Unit> > Handle(Command request, CancellationToken cancellationToken)
{
var product = await _context.Products.FindAsync(request.productId);
if (product == null)
{
return(null);
}
var user = await _context.Users
.FirstOrDefaultAsync(x => x.UserName == _userAccessor.GetUsername());
var cartItem = await _context.CartItems
.FirstOrDefaultAsync(x => x.productId == request.productId && x.userId == user.Id);
if (cartItem == null)
{
return(null);
}
_context.CartItems.Remove(cartItem);
var result = await _context.SaveChangesAsync() > 0;
if (result)
{
return(ResultVm <Unit> .Success(Unit.Value));
}
return(ResultVm <Unit> .Failure("Problem removing item from cart"));
}
public static ResultVm <List <T> > FromSuccessList <T>(this ResultVm <List <T> > rvm, List <T> objs)
{
rvm.Result = Constants.SUCCESS_RESULT;
rvm.Data = objs;
return(rvm);
}
public IActionResult ManageScores(ResultVm result)
{
var currentUser = User.Identity.Name;
var resultWithCurrentPoints = _usersRolesAndScoresService.ManageScores(result, currentUser);
return(View(resultWithCurrentPoints));
}
public R.ResultVm <bool> AddCheckin(string serverName, Checkin checkin)
{
var result = new R.ResultVm <bool>().FromEmptyFailure();
Demand <string> .That(serverName, "serverName").HasNonEmptyValue().HasMaxChars(255).Result(result);
Demand <double> .That(checkin.RamUtilization, "checkin.RamUtilization").IsGreaterThan(0.0D).Result(result);
Demand <double> .That(checkin.CpuUtilization, "checkin.CpuUtilization").IsGreaterThan(0.0D).IsLessThanOrEqualTo(1.0D).Result(result);
//Demand<DateTime>.That(checkin.SampleTime, "checkin.SampleTime").IsAfter(DateTime.Now.AddMinutes(-10.0D)).IsBefore(DateTime.Now.AddMinutes(10.00D)).Result(result);
if (result.Errors.Count == 0)
{
try
{
result = new ResultVm <bool>().FromSuccessObject(_repo.AddCheckin(serverName, checkin));
}
catch (Exception ex)
{
result = new ResultVm <bool>().FromException(ex);
}
}
else
{
result.Data = false;
}
return(result);
}
public async Task <ResultVm <Unit> > Handle(Command request, CancellationToken cancellationToken)
{
var product = await _context.Products.Include(p => p.Pictures)
.FirstOrDefaultAsync(x => x.Id == request.proId);
if (product.Pictures == null || product.Pictures.Count < 1)
{
return(ResultVm <Unit> .Success(Unit.Value));
}
foreach (var item in product.Pictures)
{
var result = await _photoAccessor.DeletePhoto(item.Id);
if (result == null)
{
return(ResultVm <Unit> .Failure("Problem deleting picture from Cloudinary"));
}
product.Pictures.Remove(item);
_context.Remove(item);
}
var success = await _context.SaveChangesAsync() > 0;
if (success)
{
return(ResultVm <Unit> .Success(Unit.Value));
}
return(ResultVm <Unit> .Failure("Problem deleting all picture from API"));
}
public ResultVm ToResultVm(int gender, SchoolClass aclass, Exercise exercise)
{
var model = new ResultVm
{
ClassId = aclass.Id,
ExerciseId = exercise.Id,
ClassName = aclass.Name,
ExerciseName = exercise.Name,
IsTime = exercise.Unit.IsTime,
Students = aclass.Students.Where(x => x.Gender == (Gender)gender).Select(x => new StudentVm
{
Name = x.Name,
Id = x.Id,
Results = x.Results.Where(r => r.IsTodaysResult && r.ExerciseId == exercise.Id)
.Select(o => new StudentVm.ResultVm
{
Id = o.Id,
ResultValue = o.ResultValue.Value.ToString()
}).ToList(),
BestResult = x.Results.Where(r => r.ExerciseId == exercise.Id && !r.IsTodaysResult)
.OrderByDescending(r => r.ResultValue.Value).Select(r => r.ResultValue.Value.ToString())
.FirstOrDefault()
}).ToList()
};
return(model);
}
public static ResultVm <T> FromErrorString <T>(this ResultVm <T> rvm, string error)
{
rvm.Result = Constants.FAILED_RESULT;
rvm.Errors = new List <string>();
rvm.Errors.Add(error);
return(rvm);
}
public async Task <ResultVm <List <ProductVm> > > Handle(Query request, CancellationToken cancellationToken)
{
var products = await _context.Products
.ProjectTo <ProductVm>(_mapper.ConfigurationProvider, new { currentUsername = _userAccessor.GetUsername() })
.ToListAsync(cancellationToken);
return(ResultVm <List <ProductVm> > .Success(products));
}
public static ResultVm <T> FromException <T>(this ResultVm <T> rvm, Exception ex)
{
rvm.Result = Constants.FAILED_RESULT;
rvm.Errors = new List <string>();
rvm.Errors.Add(GetErrorString(ex, 0));
return(rvm);
}
public async Task <ResultVm <ProductVm> > Handle(Query request, CancellationToken cancellationToken)
{
var product = await _context.Products
.ProjectTo <ProductVm>(_mapper.ConfigurationProvider, new { currentUsername = _userAccessor.GetUsername() })
.FirstOrDefaultAsync(x => x.Id == request.Id);
return(ResultVm <ProductVm> .Success(product));
}
public async Task <ResultVm <List <CategoryVm> > > Handle(Query request, CancellationToken cancellationToken)
{
var categories = await _context.Categories
.ProjectTo <CategoryVm>(_mapper.ConfigurationProvider)
.ToListAsync();
return(ResultVm <List <CategoryVm> > .Success(categories));
}
public async Task <ResultVm <Unit> > Handle(Command request, CancellationToken cancellationToken)
{
var user = await _context.Users.FirstOrDefaultAsync(x => x.UserName == _userAccessor.GetUsername());
// Add order
Order order = new Order
{
User = user,
};
_context.Orders.Add(order);
var result1 = await _context.SaveChangesAsync() > 0;
if (!result1)
{
return(ResultVm <Unit> .Failure("#Checkout: Problem with result 1 -> adding new Order"));
}
// Add list of order detail
foreach (var proID in request.productIds)
{
var product = await _context.Products.FindAsync(proID);
if (product == null)
{
return(null);
}
var cart = await _context.CartItems.FirstOrDefaultAsync(x => x.productId == product.Id && x.userId == user.Id);
if (cart == null)
{
return(null);
}
OrderDetail orderDetail = new OrderDetail
{
orderId = 1,
Order = order,
Product = product,
price = product.Price,
quantity = cart.quantity,
totalPrice = product.Price * cart.quantity
};
order.orders.Add(orderDetail);
_context.CartItems.Remove(cart);
}
var result2 = await _context.SaveChangesAsync() > 0;
if (result2)
{
return(ResultVm <Unit> .Success(Unit.Value));
}
return(ResultVm <Unit> .Failure("Problem with checkout"));
}
public async Task <ResultVm <List <BrandVm> > > Handle(Query request, CancellationToken cancellationToken)
{
var brands = await _context.Brands
.ToListAsync();
var brandVms = _mapper.Map <List <Brand>, List <BrandVm> >(brands);
return(ResultVm <List <BrandVm> > .Success(brandVms));
}
public async Task <ResultVm <List <OrderVm> > > Handle(Query request, CancellationToken cancellationToken)
{
var orders = await _context.Orders
.Where(x => x.User.UserName == _userAccessor.GetUsername())
.ProjectTo <OrderVm>(_mapper.ConfigurationProvider)
.ToListAsync();
return(ResultVm <List <OrderVm> > .Success(orders));
}
public async Task <ResultVm <List <OrderDetailVm> > > Handle(Query request, CancellationToken cancellationToken)
{
var orderDetail = await _context.OrderDetails
.Where(x => x.orderId == request.orderId)
.ProjectTo <OrderDetailVm>(_mapper.ConfigurationProvider)
.ToListAsync();
return(ResultVm <List <OrderDetailVm> > .Success(orderDetail));
}
public async Task <ActionResult> Index(UploadFilesVM model)
{
if (ModelState.IsValid)
{
if (model.Files != null && model.Files.Any())
{
var resultVm = new ResultVm()
{
Logs = new List <ResultLogVm>()
};
var analyzer = new Analyzer();
try
{
foreach (var file in model.Files)
{
try
{
var res = await analyzer.AnalyzeLog(file.OpenReadStream(), model.Format);
resultVm.Logs.Add(new ResultLogVm
{
File = file.FileName,
Clients = res.Select(r => new ResultClientVm
{
FQDN = r.FQDN,
IP = r.IP.ToString(),
RequestCount = r.RequestCount
})
});
}
catch (Exception e)
{
throw new Exception($"Failed to analyze file {file.FileName}.", e);
}
}
TempData.Put("result", resultVm);
return(this.RedirectToAction(nameof(Result)));
}
catch (Exception e)
{
ModelState.AddModelError("Files", e.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, "No files provided");
}
}
return(View(model));
}
public async Task <ResultVm <CategoryVm> > Handle(Query request, CancellationToken cancellationToken)
{
var category = await _context.Categories
.ProjectTo <CategoryVm>(_mapper.ConfigurationProvider)
.FirstOrDefaultAsync(x => x.Id == request.Id);
if (category == null)
{
return(ResultVm <CategoryVm> .Failure("Category not found!"));
}
return(ResultVm <CategoryVm> .Success(category));
}
public async Task <ResultVm <ProfileVm> > Handle(Query request, CancellationToken cancellationToken)
{
var user = await _context.Users
.ProjectTo <ProfileVm>(_mapper.ConfigurationProvider, new { currentUsername = _userAccessor.GetUsername() })
.SingleOrDefaultAsync(x => x.Username == _userAccessor.GetUsername());
if (user == null)
{
return(null);
}
return(ResultVm <ProfileVm> .Success(user));
}
public async Task <ResultVm <string> > CheckOut(List <int> proID)
{
//Send Json body
var content = new StringContent(JsonConvert.SerializeObject(proID)
, Encoding.UTF8, "application/json");
var token = _httpContextAccessor.HttpContext.Request.Cookies["jwt"];
var client = _httpClientFactory.CreateClient();
client.SetBearerToken(token);
var response = await client.PostAsync(_config["API:Default"] + $"/Order/checkout", content);
response.EnsureSuccessStatusCode();
return(ResultVm <string> .Success("SuccessFull checkout"));
}
public async Task <ResultVm <UserVm> > postRegister(RegisterVm register)
{
//Send Json body
var content = new StringContent(JsonConvert.SerializeObject(register)
, Encoding.UTF8, "application/json");
var client = _httpClientFactory.CreateClient();
var response = await client.PostAsync(_config["API:Default"] + "/api/Account/register", content);
if (response.IsSuccessStatusCode)
{
return(ResultVm <UserVm> .Success(await response.Content.ReadAsAsync <UserVm>()));
}
return(ResultVm <UserVm> .Failure(response.Content.ReadAsStringAsync().Result.ToString()));
}
public async Task <ResultVm <ProfileVm> > getProfile()
{
var client = _httpClientFactory.CreateClient();
var token = _httpContextAccessor.HttpContext.Request.Cookies["jwt"];
client.SetBearerToken(token);
var response = await client.GetAsync(_config["API:Default"] + "/Profile");
if (response.IsSuccessStatusCode)
{
return(ResultVm <ProfileVm> .Success(await response.Content.ReadAsAsync <ProfileVm>()));
}
return(ResultVm <ProfileVm> .Failure(response.Content.ReadAsStringAsync().Result.ToString()));
}
public async Task <ResultVm <string> > SetRating(int productID, double rate)
{
var client = _httpClientFactory.CreateClient();
var token = _httpContextAccessor.HttpContext.Request.Cookies["jwt"];
client.SetBearerToken(token);
var response = await client.PostAsync(_config["API:Default"] + $"/Rate/{productID}?rate={rate}", null);
if (response.IsSuccessStatusCode)
{
return(ResultVm <string> .Success("complete"));
}
return(ResultVm <string> .Failure("failed to rate a product"));
}
public async Task <ResultVm <string> > DeletFromCart(int productID)
{
var client = _httpClientFactory.CreateClient();
var token = _httpContextAccessor.HttpContext.Request.Cookies["jwt"];
client.SetBearerToken(token);
var response = await client.DeleteAsync(_config["API:Default"] + $"/Profile/DeleteFromCart/{productID}");
if (response.IsSuccessStatusCode)
{
return(ResultVm <string> .Success("complete"));
}
return(ResultVm <string> .Failure("failed to add product to cart"));
}
