public void TestCreate()
{
// Arrange
var dish1 = new Dish
(
"Brötchen",
"Small bread",
1.5M,
Category.Starter,
TimeOfDay.Weekends,
true,
1
);
// Act
var dish2 = crudService.Create(dish1);
// Assert
Assert.NotNull(dish2);
Assert.IsType <Dish>(dish2);
Assert.NotNull(dish2.Id);
Assert.Equal(dish2.Name, dish1.Name);
Assert.Equal(dish2.ShortDesc, dish1.ShortDesc);
Assert.Equal(dish2.Category, dish1.Category);
Assert.Equal(dish2.Availability, dish1.Availability);
Assert.Equal(dish2.Price, dish1.Price);
Assert.Equal(dish2.Active, dish1.Active);
Assert.Equal(dish2.WaitingTime, dish1.WaitingTime);
// For cleaning:
fixture.DishesToDelete.Add(dish2);
}
public async Task <ActionResult> Registration(RegistrationViewModel model)
{
Task task = GetLanguages(model);
if (ModelState.IsValid)
{
if (model.Password == model.ConfirmPassword)
{
BaseResponseModelPost result = await _crudService.Create(model, null, UserService.UserEntity);
AddMessageToModel(model, result.Message, !result.Success);
if (result.Success)
{
AddViewModelToTempData(model);
return(RedirectToAction("Login"));
}
}
else
{
AddMessageToModel(model, "Password and confirmed password are not equal!");
}
}
await Task.WhenAll(task);
return(View(model));
}
public async Task <IActionResult> Create([FromBody] PeopleMarkViewModel model)
{
if (!ModelState.IsValid)
{
var errorMessage = string.Empty;
foreach (var error in ModelState)
{
foreach (var message in error.Value.Errors)
{
errorMessage += $"{message.ErrorMessage}\n";
}
}
return(StatusCode(500, ApiResult.FailResult(errorMessage)));
}
try
{
await _crudService.Create(model);
}
catch (DbUpdateException)
{
return(StatusCode(500,
ApiResult.FailResult("Something went wrong while inserting data to database. Notice that \"Full Name\" should be unique.")));
}
catch (Exception ex)
{
return(StatusCode(500, ApiResult.FailResult(ex.Message)));
}
return(Ok(ApiResult.SuccessResult()));
}
public async Task <IActionResult> OnPostAsync()
{
UserConferenceBinding existingBinding = _ucBindingService.GetAll().Result
.FindAll(binding => binding.UserId.Equals(UserId))
.Find(binding => binding.ConferenceId.Equals(ConferenceId));
UserConferenceBinding newBinding = new UserConferenceBinding
{
UserId = UserId,
ConferenceId = ConferenceId,
UserType = UserType
};
if (existingBinding != null)
{
if (existingBinding.UserType != UserType)
{
newBinding.UserConferenceBindingId = existingBinding.UserConferenceBindingId;
BindingCreated = await _ucBindingService.Update(newBinding);
}
}
else
{
BindingCreated = await _ucBindingService.Create(newBinding);
}
Users = await _userService.GetAll();
Conferences = await _conferenceService.GetAll();
SelectListUsers = new SelectList(Users, nameof(Models.User.UserId), nameof(Models.User.Email));
SelectListConferences = new SelectList(Conferences, nameof(Conference.ConferenceId), nameof(Conference.Name));
return(Page());
}
public async Task <IActionResult> OnPostAsync(string imageName, int?id)
{
EventId = id;
NewEvent.ConferenceId = 1;
if (Duration != null)
{
NewEvent.Duration = TimeSpan.FromMinutes((int)Duration);
}
NewEvent.Image = imageName;
if (!ModelState.IsValid)
{
return(Page());
}
if (EventId == null)
{
await _eventService.Create(NewEvent);
}
else
{
NewEvent.EventId = (int)EventId;
await _eventService.Update(NewEvent);
}
return(RedirectToPage("/Events/EventIndex"));
}
//public async Task<IActionResult> OnGetAsync()
//{
//}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
Speaker newSpeaker = new Speaker();
newSpeaker.SpeakerId = Id ?? 0;
newSpeaker.FirstName = speak.FirstName;
newSpeaker.LastName = speak.LastName;
newSpeaker.Email = speak.Email;
newSpeaker.Image = speak.Image;
newSpeaker.Description = speak.Description;
newSpeaker.Title = speak.Title;
if (IsNewEntry)
{
await SpeakerService.Create(newSpeaker);
}
else
{
await SpeakerService.Update(newSpeaker);
}
return(RedirectToPage("/Admin/Speaker/speakerCreate"));
}
public async Task <IActionResult> OnPostAsync(int?venueId, int?floorId)
{
if (floorId == 0)
{
Venues = await _venueService.GetAll();
Floors = await _floorService.GetAll();
Floors.Insert(0, new Floor());
SelectListFloors = new SelectList(Floors.FindAll(floor => floor.VenueId.Equals(venueId) || floor.VenueId == 0), nameof(Floor.FloorId), nameof(Floor.Name));
NewRoom.VenueId = (int)venueId;
VenueId = (int)venueId;
ModelState.Clear();
return(Page());
}
NewRoom.VenueId = (int)venueId;
NewRoom.FloorId = (int)floorId;
if (!ModelState.IsValid)
{
return(RedirectToPage("Index"));
}
await _roomService.Create(NewRoom);
return(RedirectToPage("Index"));
}
public async Task <IActionResult> CreateFlow([FromBody] CreateFlowRequest request)
{
try
{
var validator = new CreateFlowRequestValidator();
var validation = validator.Validate(request);
if (!validation.IsValid)
{
return(BadRequest(validation.Errors));
}
var flowModel = new FlowModel();
flowModel.Name = request.Name;
flowModel.States = new List <FlowStateModel>();
foreach (var state in request.States)
{
flowModel.States.Add(new FlowStateModel
{
StateId = state.StateId,
Order = state.Order
});
}
var id = await _flowService.Create(flowModel);
return(Ok(id));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult Create(MasterViewModel master)
{
if (ModelState.IsValid)
{
var createdMaster = new List <Master>();
var error = new List <Error>();
try
{
createdMaster.Add(_crudService.Create(master));
User user = new User {
Phone = master.Phone, Password = master.Password, FullName = master.FullName, RoleId = userId
};
_context.Users.Add(user);
_context.SaveChanges();
}
catch (ServiceOperationException exception)
{
ViewBag.Error = ErrorFactory.IdentifyExceptionByType(exception).Description;
return(View(master));
}
return(RedirectToAction("Get", "MasterServices", new { masterId = master.Id }));
}
return(View(master));
}
public IActionResult Create([FromBody] JobSubmissionRequest model)
{
var user = _userService.GetByUserName(User.FindFirstValue(ClaimTypes.Name));
var submission = _mapper.Map <JobSubmission>(model);
if (!_jobService.Exists(submission.JobId))
{
return(Ok(new BaseResponse("Job Not Found!")));
}
if (_jobSubmissionService.AlreadySubmitted(user.Client.Id, submission.JobId))
{
return(Ok(new BaseResponse("Already Submitted!")));
}
if (_jobSubmissionService.AlreadyAcceptedOtherSubmit(submission.JobId))
{
return(Ok(new BaseResponse("Already Accepted Other Submission!")));
}
submission.ClientId = user.Client.Id;
var m = _crudService.Create(submission);
return(Ok(new DataResponse <JobSubmissionResponse>(_mapper.Map <JobSubmissionResponse>(m))));
}
public async Task <IActionResult> OnPostAsync(int?eventId)
{
if (eventId == null)
{
return(BadRequest());
}
int?currentUserId = _sessionService.GetUserId(HttpContext.Session);
if (currentUserId != null)
{
Enrollment enrollment = new Enrollment
{
UserId = currentUserId,
EventId = eventId,
SignUpTime = DateTime.Now
};
SuccessfullySignedUp = await _enrollmentService.Create(enrollment);
}
await PageSetup((int)eventId);
return(Page());
}
public ActionResult Create(TCreateInput input)
{
if (!ModelState.IsValid)
{
return(View(input));
}
return(Json(new { Id = s.Create(createMapper.MapToEntity(input, new TEntity())) }));
}
public virtual ActionResult Create(TCreateInput o)
{
if (!ModelState.IsValid)
{
return(View(v.RebuildInput(o)));
}
return(Json(new { Id = s.Create(v.BuildEntity(o)) }));
}
public ActionResult Create(TInput o)
{
if (!ModelState.IsValid)
{
return(View(v.RebuildInput(o)));
}
s.Create(v.BuildEntity(o));
return(Content("ok"));
}
public async Task <IActionResult> OnPostSaveNewAsync(int?EId, int?UId)
{
// enrollment.User = UserSevice.GetFromId(enrollment.userId);
//enrollment.Event = EventSevice.GetFromId(enrollment.eventId);
await EnrollmentSevice.Create(enrollment);
return(RedirectToPage("Enrollment"));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
await featureService.Create(Feature);
return(RedirectToPage("Index"));
}
public virtual ActionResult <www.OperationResult> Create([FromBody] WebModel input)
{
var id = _service.Create(_adapter.Adapt <DbModel>(input));
return(Ok(new www.OperationResult
{
Message = $"{typeof(DbModel).Name} with the id of '{id}' was successfully created",
Id = id,
}));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
await _conferenceService.Create(Conference);
return(RedirectToPage("ConferenceIndex"));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
await floorService.Create(NewFloor);
done = true;
return(Page());
}
public async Task <IActionResult> ProjectAddPost(ProjectWorkModel model)
{
if (ModelState.IsValid)
{
var result = await _crudService.Create(model, Token, ProjectService.ProjectEntity);
AddMessageToModel(model, result.Message, !result.Success);
if (result.Success)
{
return(RedirectToActionWithId(model, "ProjectEdit", "Project", result.Id));
}
}
else
{
AddModelStateErrors(model);
}
return(View("Add", model));
}
public ActionResult Create(T entity)
{
var newEntity = _crudService.Create(entity);
if (newEntity == null)
{
return(BadRequest());
}
return(Ok($"T {newEntity.ToString()} added successfully."));
}
public ActionResult Create(TCreateInput input)
{
if (!ModelState.IsValid)
{
return(View(input));
}
var id = service.Create(createMapper.MapToEntity(input, new TEntity()));
var e = service.Get(id);
return(Json(new { Content = this.RenderView(RowViewName, new[] { e }) }));
}
public IActionResult OnPostCreate(string imageName)
{
Room.VenueId = tempVenueId;
Room.Image = imageName;
Room.Floor = _floorService.GetFromId(Room.FloorId).Result.Name;
Room.Events = _eventService.GetAll().Result.FindAll(e => e.RoomId.Equals(Room.RoomId));
foreach (int fId in SelectedFeatures)
{
Room.Features ??= new Dictionary <int, bool>();
Feature f = _featureService.GetFromId(fId).Result;
Room.Features.Add(f.FeatureId, true);
}
lock (_createRoomLock)
{
_roomService.Create(Room).Wait();
if (Room.Features != null)
{
if (Room.Features.Count != 0)
{
int maxId = 0;
maxId = _roomService.GetAll().Result.OrderByDescending(r => r.RoomId).First().RoomId;
foreach (int featureId in Room.Features.Keys)
{
RoomFeature rf = new RoomFeature
{
FeatureId = featureId, RoomId = maxId, IsAvailable = true
};
_roomFeatureService.Create(rf).Wait();
}
}
}
}
return(RedirectToPage("/Admin/RoomTest/Index"));
}
public ActionResult Create(RoomDetailsVm model)
{
if (!ModelState.IsValid)
{
model.RoomTypes = new SelectList(_roomTypeCrudService.GetAll(), "Id", "Name");
return(View("Details", model));
}
_roomCrudService.Create(_mapper.Map <RoomDetailsVm, RoomDto>(model));
return(RedirectToAction("List"));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
User.PasswordRepeat = null;
await _userService.Create(User);
return(RedirectToPage("UserIndex"));
}
public ActionResult Create(CountryInput input)
{
if (ModelState.IsValid)
{
var country = mapper.Map <CountryInput, Country>(input);
var id = countryService.Create(country);
country = countryService.Get(id);
return(Json(new { Item = country }));
}
return(Json(ModelState.GetErrorsInline()));
}
public async Task <IActionResult> OnPostSaveNewAsync(int id)
{
Theme newTheme = new Theme();
newTheme.ThemeId = id;
newTheme.Name = MyTheme.Name;
ThemeService.Create(newTheme).Wait();
Themes = await ThemeService.GetAll();
return(Page());
}
public async Task <IActionResult> PostAsync([FromBody] ObjectModelPostDTO objectModelDto, string variableId)
{
var objectModel = new ObjectModel
{
VariableId = variableId,
VariableBool = objectModelDto.VariableBool,
VariableInt = objectModelDto.VariableInt,
VariableString = objectModelDto.VariableString
};
var objectService = await crudService.Create(objectModel);
return(FromResult(objectService));
}
public virtual ActionResult Create(TViewModel viewModel)
{
//call service to create
if (ModelState.IsValid)
{
var dto = Mapper.Map <TPoco>(viewModel);
if (_service.Create(dto))
{
viewModel = Mapper.Map <TViewModel>(dto);
return(RedirectToAction("Edit", new { id = viewModel.ID }));
}
}
return(View(viewModel));
}
public async Task <IActionResult> CreateState([FromBody] CreateStateRequest request)
{
try
{
var stateModel = new StateModel();
stateModel.Name = request.StateName;
var id = await _stateService.Create(stateModel);
return(Ok(id));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
