public async Task IsTestExists() { string userName = "******"; //Configuring Application User ApplicationUser user = new ApplicationUser() { Email = userName, UserName = userName }; await _userManager.CreateAsync(user); var applicationUser = await _userManager.FindByEmailAsync(user.Email); var category = CreateCategory("category Name"); await _categoryRepository.AddCategoryAsync(category); var testCategoryAC = new List <TestCategoryAC> { new TestCategoryAC() { CategoryId = category.Id, IsSelect = true, } }; //Creating Test var test = CreateTest("English"); await _testRepository.CreateTestAsync(test, applicationUser.Id); await _testRepository.GetTestByIdAsync(test.Id, applicationUser.Id); var result = await _testRepository.IsTestExists(test.Id); Assert.True(result); }
public async Task GetTestInstructionsAsyncTest() { //Creating test var test = await CreateTestAsync(); //Creating test category var category1 = CreateCategory("Mathematics"); await _categoryRepository.AddCategoryAsync(category1); var category2 = CreateCategory("Computer"); await _categoryRepository.AddCategoryAsync(category2); var category3 = CreateCategory("History"); await _categoryRepository.AddCategoryAsync(category3); var testCategoryAC = new List <TestCategoryAC> { new TestCategoryAC() { CategoryId = category1.Id, IsSelect = true }, new TestCategoryAC() { CategoryId = category1.Id, IsSelect = false }, new TestCategoryAC() { CategoryId = category2.Id, IsSelect = true } }; await _testRepository.AddTestCategoriesAsync(test.Id, testCategoryAC); //Creating test questions var questionList = new List <QuestionAC> { CreateQuestionAC(true, "Category1 type question", category1.Id, 1), CreateQuestionAC(false, "Category1 type question", category1.Id, 2), CreateQuestionAC(true, "Category3 type question", category3.Id, 3), CreateQuestionAC(true, "Category3 type question", category3.Id, 4), }; var testQuestionList = new List <TestQuestionAC>(); questionList.ForEach(x => { var testQuestion = new TestQuestionAC(); testQuestion.CategoryID = x.Question.CategoryID; testQuestion.Id = x.Question.Id; testQuestion.IsSelect = x.Question.IsSelect; testQuestionList.Add(testQuestion); }); await _testRepository.AddTestQuestionsAsync(testQuestionList, test.Id); var testInstruction = await _testConductRepository.GetTestInstructionsAsync(_stringConstants.MagicString); Assert.NotNull(testInstruction); }
public async Task <int> AddCategoryAsync(CategoryDTO categoryDTO) { var category = _mapper.Map <Category>(categoryDTO); await _repository.AddCategoryAsync(category); return(category.Id); }
public async Task <IActionResult> AddCategoryAsync(AddCategoryViewModel model) { if (ModelState.IsValid) { Category category = new Category { CategoryName = model.CategoryName, Description = model.Description }; var existingCategory = _categoryRepository.Categories.FirstOrDefault(p => p.CategoryName == category.CategoryName); if (existingCategory == null) { await _categoryRepository.AddCategoryAsync(category); return(RedirectToAction("Index", "Home")); } else { ModelState.AddModelError("", "The Category already exists"); } } return(View(model)); }
public async Task <IActionResult> AddCategory([FromBody] NewCategoryDto newCategory) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (await _categoryRepository.IsDuplicateCategoryAsync(newCategory)) { ModelState.AddModelError("category", "Category already exists"); return(BadRequest(ModelState)); } var categoryId = await _categoryRepository.AddCategoryAsync(newCategory); if (categoryId > 0) { return(Ok(categoryId)); } return(StatusCode(500, "An error ocurred in server")); } catch (Exception e) { _logger.LogCritical($"POST {Route} - {e.GetType().Name} - {e.Message} - {e.StackTrace}"); return(StatusCode(500, "An error ocurred in server")); } }
public async Task <IActionResult> Add(CategoryDTO category) { var entity = Mapper.Map(category); await categoryRepository.AddCategoryAsync(entity); await unitOfWork.CompleteAsync(); return(Accepted()); }
public async Task <IActionResult> Create([Bind("IdCategory,Name,PlaceDescription,Description,UpToDate,IdRegion")] Category category) { if (ModelState.IsValid) { await _categoryRepository.AddCategoryAsync(category); return(RedirectToAction(nameof(Index))); } return(View(category)); }
public async Task <IActionResult> AddCategory(Category model) { if (ModelState.IsValid) { var result = await _repo.AddCategoryAsync(model); if (result != null) { return(Ok()); } } return(BadRequest()); }
public async Task <IActionResult> Post([FromBody] Category category) { if (!ModelState.IsValid) { return(BadRequest()); } var createdItem = await _categoryRepo.AddCategoryAsync(category); return(CreatedAtAction( actionName: nameof(Get), routeValues: new { id = createdItem.CategoryId }, value: createdItem)); }
public async Task GetAllCategoriesTest() { var category = CreateCategory(); await _categoryRepository.AddCategoryAsync(category); var result = await _categoryRepository.GetAllCategoriesAsync(); Assert.True(result.Count() == 1); }
private void SeedDatabase() { var categories = new List <CategoryEntity> { new CategoryEntity { Name = "Programming", Quizes = new List <QuizEntity> { new QuizEntity { Name = "Basic", Words = new List <WordEntity> { new WordEntity { Name = "Spreadsheet" }, new WordEntity { Name = "Excel" } } }, new QuizEntity { Name = "Intermediate", Words = new List <WordEntity> { } }, new QuizEntity { Name = "Advanced", Words = new List <WordEntity> { } } } }, new CategoryEntity("Office"), new CategoryEntity("Graphics") }; foreach (var item in categories) { _categoryRepository.AddCategoryAsync(item); } _unitOfWork.CompleteAsync(); }
public async Task <IActionResult> AddCategoryAsync([FromBody] Category category) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (await _categoryRepository.IsCategoryExistAsync(category.CategoryName, category.Id)) { ModelState.AddModelError(_stringConstants.ErrorKey, _stringConstants.CategoryNameExistsError); return(BadRequest(ModelState)); } await _categoryRepository.AddCategoryAsync(category); return(Ok(category)); }
public async Task <IActionResult> Create([Bind("Id,Name,ImageFile")] Category category) { if (ModelState.IsValid) { category.Id = Guid.NewGuid(); category.CategoryImage = await fileManager.UploadImage(category.ImageFile); await _repository.AddCategoryAsync(category); await _repository.SaveAsync(); return(RedirectToAction(nameof(Index))); } return(View(category)); }
public async Task <ActionResult> CreateCategoryAsync(CategoryDto category) { if (category == null) { return(BadRequest()); } var categoryModel = _mapper.Map <Category>(category); await _categoryRepository.AddCategoryAsync(categoryModel); if (await _categoryRepository.SaveChangesAsync() != false) { var categoryDto = _mapper.Map <CategoryDto>(categoryModel); return(CreatedAtRoute("GetCategory", new { categoryId = categoryDto.CategoryId }, categoryDto)); } return(BadRequest()); }
public async Task <CategoryResponse> AddCategoryAsync(Category category) { try { await categoryRepository.AddCategoryAsync(category); await unitOfWork.CompleteAsync(); return(new CategoryResponse(category)); } catch (Exception ex) { return(new CategoryResponse("Category Eklenirken Hata Alındı : Hata " + ex.Message.ToString())); throw; } }
public async Task <ActionResult> Post([FromBody] CategoryCreationDTO categoryCreationDTO) { try { var category = mapper.Map <CategoryEntity>(categoryCreationDTO); category.Status = 1; await repository.AddCategoryAsync(category); var categoryDTO = mapper.Map <CategoryDTO>(category); return(new CreatedAtRouteResult("getCategory", new { id = category.CategoryId }, categoryDTO)); } catch (Exception) { return(StatusCode(500)); } }
public async Task AddCategoryAsync(CategoryDTO category) { await Task.Run(async() => { if (category == null) { throw new ArgumentNullException(nameof(category)); } _categoryRepository.Configure(); var categoryDAL = new Category { Id = Guid.NewGuid() }; categoryDAL.InjectFrom(category); await _categoryRepository.AddCategoryAsync(categoryDAL); }); }
/// <summary> /// Creates Coding Question /// </summary> /// <returns>Created CodingQuestion object</returns> private async Task <QuestionAC> CreateCodingQuestion() { var categoryToCreate = CreateCategory(); await _categoryRepository.AddCategoryAsync(categoryToCreate); QuestionAC codingQuestion = new QuestionAC { Question = new QuestionDetailAC { QuestionDetail = "<h1>Write a program to add two number</h1>", CategoryID = categoryToCreate.Id, DifficultyLevel = DifficultyLevel.Easy, QuestionType = QuestionType.Programming }, CodeSnippetQuestion = new CodeSnippetQuestionAC { CheckCodeComplexity = true, CheckTimeComplexity = true, RunBasicTestCase = true, RunCornerTestCase = false, RunNecessaryTestCase = false, LanguageList = new String[] { "Java", "C" }, CodeSnippetQuestionTestCases = new List <CodeSnippetQuestionTestCases>() { new CodeSnippetQuestionTestCases() { TestCaseTitle = "Necessary check", TestCaseDescription = "This case must be successfuly passed", TestCaseMarks = 10.00, TestCaseType = TestCaseType.Necessary, TestCaseInput = "2+2", TestCaseOutput = "4", } } }, SingleMultipleAnswerQuestion = null }; return(codingQuestion); }
public async Task <ActionResult> AddCategory(CategoryAddDto categoryAddDto) { var category = _mapper.Map <Category>(categoryAddDto); try { if (categoryAddDto == null) { return(BadRequest()); } var createdCategory = await _categoryRepository.AddCategoryAsync(category); return(CreatedAtAction(nameof(GetCategory), new { Id = createdCategory.Id }, createdCategory)); } catch (Exception) { return(StatusCode(StatusCodes.Status500InternalServerError, "Erorr adding data to the database")); } }
public async Task <CategoryResponseObject> AddCategoryAsync(CategoryRequestObject category) { var date = DateTimeOffset.Now; var subCat = _mapper.Map <List <SubCategory> >(category.SubCategories); subCat.ForEach(s => s.CreatedBy = category.CreatedBy); var cat = _mapper.Map <Category>(category); cat.TimeStampCreated = date; cat.SubCategories = subCat; var res = await _catRepo.AddCategoryAsync(cat); if (res == null) { return(null); } var result = _mapper.Map <CategoryResponseObject>(res); return(result); }
public async Task <IActionResult> AddCategory([FromBody] CategoryResource categoryResource) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var category = mapper.Map <CategoryResource, Category>(categoryResource); category.LastUpdate = DateTime.Now; categoriesRepository.AddCategoryAsync(category); await unitOfWork.CompleteAsync(); var newCategory = await categoriesRepository.GetCategoryByIdAsync(category.Id); return(Ok(mapper.Map <Category, CategoryResource>(newCategory))); } catch (System.Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <Category> SaveCategoryAsync(string category, string parentCategory = null) { return(await _categoryRepository.AddCategoryAsync(category, parentCategory)); }
public async Task <Unit> Handle(CreateCategoryCommand request, CancellationToken cancellationToken) { await _categoryRepository.AddCategoryAsync(Category.CreateCategory(request.CategoryName, request.Description)); return(Unit.Value);; }
public async Task AddCategoryAsync(Category category) { await categoryRepository.AddCategoryAsync(category, ApiUrl.BASEURL); }
public async Task <IResponseModel> AddCategoryAsync(ICategoryModel model) => await _categoryRepo.AddCategoryAsync(model);
public async Task AddCategoryAsync(Guid id, string name, string description) { await _repository.AddCategoryAsync(new Category(id, name, description)); }
public async Task GetAllAttendeeMarksDetailsAsyncTest() { //create test var createTest = await CreateTestAsync(); //create category var category = CreateCategory("History"); await _categoryRepository.AddCategoryAsync(category); //create question var question1 = CreateQuestionAc(true, "first Question", category.Id, 1, QuestionType.Multiple); var question2 = CreateCodingQuestionAc(true, category.Id, 2, QuestionType.Programming); await _questionRepository.AddSingleMultipleAnswerQuestionAsync(question1, createTest.CreatedByUserId); await _questionRepository.AddCodeSnippetQuestionAsync(question2, createTest.CreatedByUserId); var questionId1 = (await _trappistDbContext.Question.SingleAsync(x => x.QuestionDetail == question1.Question.QuestionDetail)).Id; var questionId2 = (await _trappistDbContext.Question.SingleAsync(x => x.QuestionDetail == question2.Question.QuestionDetail)).Id; //add test category var categoryList = new List <DomainModel.Models.Category.Category>(); categoryList.Add(category); var testCategoryList = new List <TestCategoryAC> { new TestCategoryAC { CategoryId = category.Id, IsSelect = true, } }; await _testRepository.AddTestCategoriesAsync(createTest.Id, testCategoryList); //add test Question var questionList = new List <TestQuestionAC> { new TestQuestionAC() { Id = question1.Question.Id, CategoryID = question1.Question.CategoryID, IsSelect = question1.Question.IsSelect }, new TestQuestionAC() { Id = question2.Question.Id, IsSelect = question2.Question.IsSelect, CategoryID = question2.Question.CategoryID } }; await _testRepository.AddTestQuestionsAsync(questionList, createTest.Id); //create test attednee var testAttendee = CreateTestAttendee(createTest.Id); await _testConductRepository.RegisterTestAttendeesAsync(testAttendee); //AddTestAnswer var answer1 = CreateAnswerAc(questionId1); await _testConductRepository.AddAnswerAsync(testAttendee.Id, answer1, 0.0); var answer2 = new TestAnswerAC() { OptionChoice = new List <int>(), QuestionId = questionId2, Code = new Code() { Input = "input", Source = "source", Language = ProgrammingLanguage.C }, QuestionStatus = QuestionStatus.answered }; await _testConductRepository.AddAnswerAsync(testAttendee.Id, answer2, 0.0); //create test conduct var testConduct1 = new DomainModel.Models.TestConduct.TestConduct() { Id = 1, QuestionId = answer1.QuestionId, QuestionStatus = answer1.QuestionStatus, TestAttendeeId = testAttendee.Id }; var testConduct2 = new DomainModel.Models.TestConduct.TestConduct() { Id = 2, QuestionId = answer2.QuestionId, QuestionStatus = answer2.QuestionStatus, TestAttendeeId = testAttendee.Id }; await _trappistDbContext.TestConduct.AddAsync(testConduct1); await _trappistDbContext.TestConduct.AddAsync(testConduct2); await _trappistDbContext.SaveChangesAsync(); AddTestAnswer(answer1, testConduct1.Id); AddTestAnswer(answer2, testConduct2.Id); //add test code solution var codeSolution1 = new TestCodeSolution() { TestAttendeeId = testAttendee.Id, QuestionId = questionId2, Solution = answer2.Code.Source, Language = answer2.Code.Language, Score = 1 }; var codeSolution2 = new TestCodeSolution() { TestAttendeeId = testAttendee.Id, QuestionId = questionId2, Solution = answer2.Code.Source, Language = answer2.Code.Language, Score = 0 }; await _trappistDbContext.TestCodeSolution.AddAsync(codeSolution1); await _trappistDbContext.TestCodeSolution.AddAsync(codeSolution2); await _trappistDbContext.SaveChangesAsync(); var allAttendeeMarksDetails = await _reportRepository.GetAllAttendeeMarksDetailsAsync(createTest.Id); var totalQuestionAttempted = allAttendeeMarksDetails.First().NoOfQuestionAttempted; var easyQuestionAttempted = allAttendeeMarksDetails.First().EasyQuestionAttempted; Assert.Equal(2, easyQuestionAttempted); Assert.Equal(2, totalQuestionAttempted); }
public async Task <ActionResult <CategoryDto> > AddCategory(CategoryDto categoryDto) { return(await _categoryRepository.AddCategoryAsync(categoryDto)); }
public async Task <CategoryViewModel> AddCategoryAsync(Category category) { await ClearGetAllKeysAsync(); return(await _categoryRepository.AddCategoryAsync(category)); }
public async Task AddCategory(Category category) { await _categoryRepository.AddCategoryAsync(category); }