public ValidationAppResult Update(EventTypeViewModel eventTypeViewModel) { var eventType = Mapping.EventTypeMapper.FromViewModelToDomain(eventTypeViewModel); BeginTransaction(); var result = eventTypeService.Update(eventType); if (result.IsValid) { Commit(); } return(FromDomainToApplicationResult(result)); }
/// <summary> /// Convert EventType Object into EventType Entity /// </summary> ///<param name="model">EventType</param> ///<param name="EventTypeEntity">DataAccess.EventType</param> ///<returns>DataAccess.EventType</returns> public static DataAccess.EventType ToEntity(this EventTypeViewModel model, DataAccess.EventType entity) { if (entity.Id == 0) { entity.CreatedUserId = model.SessionUserId; entity.Discriminator = model.Discriminator; } else { entity.UpdatedUserId = model.SessionUserId; entity.UpdatedTimestamp = DateTime.Now; } entity.Name = model.Name; entity.IsActive = model.IsActive; return(entity); }
public async Task <IActionResult> PostEventType([FromBody] EventTypeViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var eventType = new EventType { Name = model.Name }; _context.EventTypes.Add(eventType); await _context.SaveChangesAsync(); return(CreatedAtAction("GetEventType", new { id = eventType.Id }, eventType)); }
public async Task <IHttpActionResult> Put(Guid key, EventTypeViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { await _eventTypeService.UpdateAsync(model); _unitOfWorkAsync.Commit(); return(Updated(model)); } catch (Exception e) { throw e; } }
public ActionResult Edit(EventTypeViewModel model) { if (ModelState.IsValid) { var entity = Mapper.Map <EventType>(model); entity = _eventtypeRepository.Update(entity); //_timelineService.RegisterActivity(Realm.BG, ActivityType.LocationUpdated, User.Id); Feedback.AddMessageSuccess(EventTypeResources.LocationEditSuccessMessage); return(RedirectToAction(nameof(Index), nameof(EventTypeController).RemoveControllerSuffix())); } model = BuilModel(model); return(View("Manager", model)); }
public EventTypeViewModel GetEventTypeByName(string name) { EventTypeViewModel eventType = null; try { eventType = (from n in db.EventTypes.Where(x => x.EventTypeName == name) select new EventTypeViewModel { EventTypeName = n.EventTypeName, EventTypeId = n.EventTypeId }).FirstOrDefault(); } catch (Exception ex) { throw ex; } return(eventType); }
public async Task <EventType> AddEventType(EventTypeViewModel eventType) { EventType itemCollections = null; try { itemCollections = new EventType { EventTypeName = eventType.EventTypeName, }; db.EventTypes.Add(itemCollections); await db.SaveChangesAsync(); } catch (Exception ex) { //log.Error(ex.Message); throw ex; } return(itemCollections); }
public async Task <IActionResult> Create(EventTypeViewModel model) { if (ModelState.IsValid) { var eventType = new EventType() { Id = Guid.NewGuid(), Name = model.Name, IsDualPlayer = model.IsDualPlayer, SportId = model.SportId, }; _context.EventTypes.Add(eventType); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index), new { sportId = model.SportId })); } ViewData["sportId"] = model.SportId; return(View(model)); }
public EventType Insert(EventTypeViewModel model, string CurrentId) { var find = Queryable().Where(x => x.Name == model.Name && x.Delete == false).FirstOrDefault(); if (find != null) { throw new Exception("Loại sự kiện đã tồn tại"); } else { var data = new EventType(); data.Name = model.Name; data.CreatDate = DateTime.Now; data.UserAccount = _userRepository.Find(CurrentId); data.Delete = false; data.LastModifiedDate = DateTime.Now; //data.UserAccount = _userRepository.Find(HttpContext.Current.User.Identity.GetUserId()); base.Insert(data); return(data); } }
public ActionResult Edit( [Bind(Include = "EventTypeId,Name,NumberOfDaysToWarning,Active")] EventTypeViewModel eventTypeViewModel) { if (ModelState.IsValid) { var result = eventTypeAppService.Update(eventTypeViewModel); if (!result.IsValid) { foreach (var validationAppError in result.Errors) { ModelState.AddModelError(string.Empty, validationAppError.Message); } return(View(eventTypeViewModel)); } return(RedirectToAction(nameof(Index))); } return(View(eventTypeViewModel)); }
public async Task <ActionResult> Create( [Bind(Include = "EventTypeId,Name,NumberOfDaysToWarning")] EventTypeViewModel eventTypeViewModel) { if (ModelState.IsValid) { var result = eventTypeAppService.Add(eventTypeViewModel); if (!result.IsValid) { foreach (var validationAppError in result.Errors) { ModelState.AddModelError(string.Empty, validationAppError.Message); } return(View(eventTypeViewModel)); } // TODO: check if this should be the action to redirect to return(RedirectToAction(nameof(Index))); } return(View(eventTypeViewModel)); }
public async Task <bool> UpdateEventTypeDetails(EventTypeViewModel eventType) { bool status = false; var getRecord = (from r in db.EventTypes.Where(x => x.EventTypeId.Equals(eventType.EventTypeId)) select r).FirstOrDefault(); if (getRecord != null) { try { getRecord.EventTypeName = eventType.EventTypeName; await db.SaveChangesAsync(); status = true; } catch (Exception ex) { status = false; throw ex; } } return(status); }
public ActionResult ViewAllEventTypes() { var eventtypes = new List <EventTypeViewModel>(); var _companyId = Convert.ToInt32(User.Identity.GetUserId()); if (_companyId > 0) { var result = _eventTypeService.GetAllEventTypes(_companyId); if (result != null && result.eventTypes.Count != 0) { foreach (var obj in result.eventTypes) { var eventtype = new EventTypeViewModel(); eventtype.Id = obj.Id; eventtype.Type = obj.Type; eventtype.Description = obj.Description; eventtypes.Add(eventtype); } } } return(View(eventtypes)); }
public async Task <IHttpActionResult> Post(EventTypeViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var stf = await _eventTypeService.InsertAsync(model, GetCurrentUserID()); _unitOfWorkAsync.Commit(); var resultObject = new EventPurposeViewModel() { ID = stf.Id, Name = stf.Name, }; return(Created(resultObject)); } catch (Exception ex) { throw ex; } }
private void BuildTree() { RootFilters = new ObservableCollection<EventTypeViewModel>(); RootFilters.Add(new EventTypeViewModel(JournalSubsystemType.System)); RootFilters.Add(new EventTypeViewModel(JournalSubsystemType.SKD)); RootFilters.Add(new EventTypeViewModel(JournalSubsystemType.GK)); foreach (JournalEventNameType enumValue in Enum.GetValues(typeof(JournalEventNameType))) if (enumValue != JournalEventNameType.NULL) { var eventTypeViewModel = new EventTypeViewModel(enumValue); switch (eventTypeViewModel.JournalSubsystemType) { case JournalSubsystemType.System: RootFilters[0].AddChild(eventTypeViewModel); break; case JournalSubsystemType.SKD: RootFilters[1].AddChild(eventTypeViewModel); break; case JournalSubsystemType.GK: RootFilters[2].AddChild(eventTypeViewModel); break; } } }
public async Task <IActionResult> Edit(Guid?id, EventTypeViewModel model) { if (id == null) { return(NotFound()); } if (ModelState.IsValid) { var eventType = await _context.EventTypes.FindAsync(id); if (eventType == null) { return(NotFound()); } eventType.Name = model.Name; await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index), new { sportId = model.SportId })); } return(View(model)); }
public void ValidatorShouldHaveErrorWhenTypeIsInvalid(EventTypeViewModel value) { ValidationResult result = _validator.Validate(value); result.Errors.Should().NotBeEmpty(); }
public async Task <EventType> InsertAsync(EventTypeViewModel model, string CurrentId) { return(await Task.Run(() => Insert(model, CurrentId))); }