private async Task <string> CreateUserAsync(string email, string name, string lastName, IDeletableEntityRepository <ApplicationUser> repo) { var user = new ApplicationUser() { FirstName = name, LastName = lastName, Email = email, UserName = email, ProfilePicture = "Test.com", ModelInformation = new ModelInformation { Age = 13, Bust = 14, Waist = 16, Hips = 14, Height = 15, Gender = Gender.Male, Ethnicity = Ethnicity.Chinese, }, UserImages = new List <UserImage> { new UserImage { ImageUrl = "Test" }, }, }; await repo.AddAsync(user); await repo.SaveChangesAsync(); return(user.Id); }
//private async Task<string> CreateUserImages(string userId, IDeletableEntityRepository<UserImage> imageRepo, IDeletableEntityRepository<ApplicationUser> repo) //{ // var userImages = new List<UserImage> // { // new UserImage { UserId = userId, ImageUrl = "testUrl1" }, // new UserImage { UserId = userId, ImageUrl = "testUrl2" }, // new UserImage { UserId = userId, ImageUrl = "testUrl3" }, // }; // foreach (var image in userImages) // { // await imageRepo.AddAsync(image); // await repo.SaveChangesAsync(); // } // return userId; //} private async Task <string> CreateUserWithImage(string email, string name, string lastName, IDeletableEntityRepository <ApplicationUser> repo) { var user = new ApplicationUser() { FirstName = name, LastName = lastName, Email = email, UserName = email, UserImages = new List <UserImage> { new UserImage { ImageUrl = "testUrl1" }, new UserImage { ImageUrl = "testUrl2" }, new UserImage { ImageUrl = "testUrl3" }, }, }; await repo.AddAsync(user); await repo.SaveChangesAsync(); return(user.Id); }
public async Task Add(SubjectInputModel model) { Subject subject = model.To <Subject>(); await repository.AddAsync(subject); await repository.SaveChangesAsync(); }
public async Task <int> Create(string id, string userId) { var package = _packageRepository.All() .SingleOrDefault(p => p.Id.Equals(id) && p.RecipientId.Equals(userId)); if (package == null) { return(0); } var price = (decimal)package.Weight * 2.67M; var receipt = new Receipt { Fee = price, RecipientId = package.RecipientId, Recipient = package.Recipient, PackageId = package.Id, Package = package, }; var status = _statusRepository.All().SingleOrDefault(s => s.Name.Equals("Acquired")); package.Status = status; _packageRepository.Update(package); await _packageRepository.SaveChangesAsync(); await _receiptRepository.AddAsync(receipt); return(await _receiptRepository.SaveChangesAsync()); }
public async Task Create(SchoolInputModel inputModel, string principalUniqueId) { var principal = _usersService.GetPrincipalByUniqueId(principalUniqueId); var school = new School { Name = inputModel.Name, Address = inputModel.Address, Type = inputModel.Type, Principal = principal }; if (inputModel.SchoolImage != null) { var fileName = inputModel.SchoolImage.Name; var uniqueFileName = Guid.NewGuid() + fileName; await _fileManagementService.SaveImageAsync("schools", uniqueFileName, inputModel.SchoolImage); school.SchoolImageName = uniqueFileName; } await _schoolsRepository.AddAsync(school); await _schoolsRepository.SaveChangesAsync(); }
public async Task Add(QuestionTypeInputModel model) { QuestionType questionType = model.To <QuestionType>(); await repository.AddAsync(questionType); await repository.SaveChangesAsync(); }
public async Task AddProduct(ProductCreateInputModel model, string imagePath) { Product product = new Product { Name = model.Name, Price = model.Price, CategoryId = model.CategoryId, Description = model.Description, }; Directory.CreateDirectory($"{imagePath}/products/"); var extension = Path.GetExtension(model.Image.FileName).TrimStart('.'); if (!this.allowedExtensions.Any(x => extension.EndsWith(x))) { throw new Exception($"Invalid image extension {extension}"); } var dbImage = new Image { Extension = extension, }; product.Image = dbImage; var physicalPath = $"{imagePath}/products/{dbImage.Id}.{extension}"; using Stream fileStream = new FileStream(physicalPath, FileMode.Create); await model.Image.CopyToAsync(fileStream); await productRepository.AddAsync(product); await productRepository.SaveChangesAsync(); }
public async Task <T> CreateTeacher <T>(TeacherInputModel inputModel) { var schoolId = int.Parse(inputModel.SchoolId); var school = _schoolsRepository.All().FirstOrDefault(s => s.Id == schoolId); if (school != null) { var teacher = new Teacher() { FirstName = inputModel.FirstName, LastName = inputModel.LastName, School = school, UniqueId = _idGeneratorService.GenerateTeacherId() }; await _teachersRepository.AddAsync(teacher); await _teachersRepository.SaveChangesAsync(); BasePersonModel baseModel = _teachersRepository.All().FirstOrDefault(t => t.UniqueId == teacher.UniqueId); return(AutoMapperConfig.MapperInstance.Map <T>(baseModel)); } throw new ArgumentException($"Sorry, we couldn't find school with id {schoolId}"); }
public async Task CreateAsync(GradeInputModel inputModel) { var studentSubject = _studentSubjectsRepository.All().FirstOrDefault(s => s.StudentId == inputModel.StudentId && s.SubjectId == inputModel.SubjectId); if (studentSubject != null) { var teacher = _teachersRepository.All().FirstOrDefault(t => t.Id == inputModel.TeacherId); if (teacher != null) { var grade = new Grade { Value = inputModel.Value, Period = inputModel.Period, Type = inputModel.Type, StudentSubject = studentSubject, Teacher = teacher }; await _gradesRepository.AddAsync(grade); await _gradesRepository.SaveChangesAsync(); return; } throw new ArgumentException($"Sorry, we couldn't find teacher with id {inputModel.TeacherId}"); } throw new ArgumentException($"Sorry, we couldn't find pair of student ({inputModel.StudentId}) and subject({inputModel.SubjectId})"); }
public async Task <int> Create(ContactFormInputModel input) { var contactForm = AutoMapperConfig.MapperInstance.Map <ContactForm>(input); await contactFormsRepository.AddAsync(contactForm); await contactFormsRepository.SaveChangesAsync(); return(contactForm.Id); }
public async Task CreateCategory(string name) { var category = new Category { Name = name, }; await categoryRepository.AddAsync(category); await categoryRepository.SaveChangesAsync(); }
public async Task CreateAsync(ExperienceCreateInputModel inputModel, int cvId) { var experience = _mapper.Map <Experience>(inputModel); experience.CVId = cvId; await _experienceRepository.AddAsync(experience); await _experienceRepository.SaveChangesAsync(); }
public async Task CreateAsync(SkillCreateInputModel inputModel, int cvId) { var skill = _mapper.Map <Skill>(inputModel); skill.CVId = cvId; await _skillsRepository.AddAsync(skill); await _skillsRepository.SaveChangesAsync(); }
public async Task CreateAsync(EducationCreateInputModel inputModel, int cvId) { var education = _mapper.Map <Education>(inputModel); education.CVId = cvId; await _educationEntityRepository.AddAsync(education); await _educationEntityRepository.SaveChangesAsync(); }
private async Task CreateBlogContentForTests(string title, string content, int blogId, IDeletableEntityRepository <BlogContent> cRepo) { var blogContent = new BlogContent { BlogId = blogId, Title = title, Content = content, }; await cRepo.AddAsync(blogContent); await cRepo.SaveChangesAsync(); }
public async Task CreateAsync(string content, int cvId, string userId) { var comment = new Comment { CVId = cvId, UserId = userId, Content = content }; await _commentsRepository.AddAsync(comment); await _commentsRepository.SaveChangesAsync(); }
public async Task <IActionResult> InsertSetting() { var random = new Random(); var setting = new Setting { Name = $"Name_{random.Next()}", Value = $"Value_{random.Next()}" }; await repository.AddAsync(setting); await repository.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); }
public async Task <T> CreateParentAsync <T>(ParentInputModel inputModel) { var studentIds = inputModel.StudentIds.Select(int.Parse); var students = _studentsRepository.All().Where(s => studentIds.Contains(s.Id)); if (students.Any()) { var parent = new Parent { FirstName = inputModel.FirstName, LastName = inputModel.LastName, PhoneNumber = inputModel.PhoneNumber, UniqueId = _idGeneratorService.GenerateParentId() }; await _parentsRepository.AddAsync(parent); await _parentsRepository.SaveChangesAsync(); foreach (var student in students) { var studentParentPair = new StudentParent { Student = student, Parent = parent }; await _studentParentsMappingRepository.AddAsync(studentParentPair); } await _studentParentsMappingRepository.SaveChangesAsync(); BasePersonModel baseModel = _parentsRepository.All().FirstOrDefault(p => p.UniqueId == parent.UniqueId); return(AutoMapperConfig.MapperInstance.Map <T>(baseModel)); } throw new ArgumentException($"Sorry, we couldn't any student with id in the following list: [{string.Join(", ", studentIds)}]"); }
public async Task Create(ReviewInputModel input) { var review = AutoMapperConfig.MapperInstance.Map <Review>(input); if (reviewsRepository.AllAsNoTracking().Any(x => x.GameId == input.GameId && x.AuthorId == input.AuthorId)) { await Task.FromException <int>( new InvalidOperationException("A review for this user already exists.")); } await reviewsRepository.AddAsync(review); await reviewsRepository.SaveChangesAsync(); }
private async Task <int> CreateImageForTest(string url, string userId, IDeletableEntityRepository <UserImage> repo) { var userImages = new UserImage { UserId = userId, ImageUrl = url, }; await repo.AddAsync(userImages); await repo.SaveChangesAsync(); return(userImages.Id); }
public async Task <int> Create(GenreInputModel input) { var genre = new Genre() { Description = input.Description, Name = input.Name, }; await genresRepository.AddAsync(genre); await genresRepository.SaveChangesAsync(); return(genre.Id); }
// Create user with no profile picture and modelInformation private async Task <string> CreateUserWithNoInformationAsync(string email, string name, string lastName, IDeletableEntityRepository <ApplicationUser> repo) { var user = new ApplicationUser() { FirstName = name, LastName = lastName, Email = email, UserName = email, }; await repo.AddAsync(user); await repo.SaveChangesAsync(); return(user.Id); }
public async Task CreateAsync(ClassInputModel inputModel) { var teacherId = int.Parse(inputModel.TeacherId); var teacher = _teachersRepository.All().FirstOrDefault(t => t.Id == teacherId); if (teacher != null) { if (teacher.Class != null) { throw new ArgumentException($"Sorry, teacher with id {teacherId} is already registered as head of another class"); } var isClassLetterNumberCombinationAlreadyOccupied = _classesRepository.All().Any(c => c.Letter == inputModel.Letter && c.YearCreated == inputModel.YearCreated && c.Year == inputModel.Year && c.Teacher.SchoolId == teacher.SchoolId); if (isClassLetterNumberCombinationAlreadyOccupied) { throw new ArgumentException($"Sorry, there is already existing class for year {inputModel.YearCreated} that's currently in {inputModel.Year} grade and with letter {inputModel.Letter}"); } var schoolClass = new Class { Letter = inputModel.Letter, Year = inputModel.Year, YearCreated = inputModel.YearCreated, Teacher = teacher }; await _classesRepository.AddAsync(schoolClass); await _classesRepository.SaveChangesAsync(); var classEntity = _classesRepository.All().First(c => c.Letter == schoolClass.Letter && c.YearCreated == schoolClass.YearCreated && c.Year == schoolClass.Year); var school = teacher.School; school.Classes.Add(classEntity); _schoolsRepository.Update(school); await _schoolsRepository.SaveChangesAsync(); return; } throw new ArgumentException($"Sorry, we couldn't find teacher with id {teacherId}"); }
public async Task <int> CreateAsync(string title, string content, int categoryId, string userId) { var post = new Post { CategoryId = categoryId, Title = title, Content = content, UserId = userId }; await _postsRepository.AddAsync(post); await _postsRepository.SaveChangesAsync(); return(post.Id); }
public async Task CreateOrder(Order order) { if (order.Delivery == true) { order.Status = GlobalConstants.Sent; } else { order.Status = GlobalConstants.Open; } orderRepository.AddAsync(order).Wait(); await orderRepository.SaveChangesAsync(); await orderItemService.CreateOrderItem(order); }
public async Task AddReservation(ReservationCreateInputModel model) { var reservation = new Reservation { StartTime = model.StartTime, NumberOfSeats = model.NumberOfSeats, Duration = model.Duration, PersonEmail = model.Email, PersonName = model.Name, PersonNumber = model.Number, }; await reservationRepository.AddAsync(reservation); await reservationRepository.SaveChangesAsync(); }
private async Task <int> CreateContactForm (string name, string email, string subject, string message, IDeletableEntityRepository <ContactFormData> repo) { var contact = new ContactFormData { Name = name, Email = email, Subject = subject, Message = message, }; await repo.AddAsync(contact); await repo.SaveChangesAsync(); return(contact.Id); }
private async Task <string> CreateUserForTests( string email, string name, string lastName, string url, IDeletableEntityRepository <ApplicationUser> repo) { var user = new ApplicationUser() { FirstName = name, LastName = lastName, Email = email, UserName = email, ProfilePicture = url, }; await repo.AddAsync(user); await repo.SaveChangesAsync(); return(user.Id); }
public async Task <T> CreatePrincipal <T>(PrincipalInputModel inputModel) { var principal = new Principal { FirstName = inputModel.FirstName, LastName = inputModel.LastName, UniqueId = _idGeneratorService.GeneratePrincipalId() }; await _principalsRepository.AddAsync(principal); await _principalsRepository.SaveChangesAsync(); BasePersonModel baseModel = _principalsRepository.All().FirstOrDefault(p => p.FirstName == inputModel.FirstName && p.LastName == inputModel.LastName); return(AutoMapperConfig.MapperInstance.Map <T>(baseModel)); }
private async Task <int> CreateBlogForTest( string title, string imageUrl, string userId, IDeletableEntityRepository <Model4You.Data.Models.Blog> blogRepo) { var blog = new Model4You.Data.Models.Blog { UserId = userId, Title = title, ImageUrl = imageUrl, }; await blogRepo.AddAsync(blog); await blogRepo.SaveChangesAsync(); return(blog.Id); }