public ActionResult EditGroup(int?groupid)
{
if (groupid == null)
{
AddApplicationMessage("Nebylo uvedeno ID skupiny", MessageSeverity.Danger);
return(RedirectToAction("Admin", "Competitions"));
}
var group = unitOfWork.GroupRepository.GetByID(groupid);
if (group == null)
{
AddApplicationMessage("Skupina nebyla nalezena", MessageSeverity.Danger);
return(RedirectToAction("Admin", "Competitions"));
}
var model = new AddGroupViewModel()
{
groupid = (int)groupid,
name = group.Name,
playoff = group.Playoff == 1 ? true : false,
compid = group.Competition,
competition = group.Competitions
};
return(View("AddGroup", model));
}
public async Task Create(AddGroupViewModel model)
{
var group = new Group();
group.Name = model.Name;
await _repo.Create(group);
}
public ActionResult Groups()
{
var model = new AddGroupViewModel();
model.Groups = blgroup.Select().ToList();
return(View(model));
}
public async Task <ActionResult> AddGroup(AddGroupViewModel model)
{
if (ModelState.IsValid)
{
Group group = new Group();
// Getting the group propoties
group.Name = model.Name;
group.Description = model.Description;
group.Category = model.Category;
// Checking if there was a image uploaded
if (model.Image != null)
{
await GroupManager.CreateAsync(group, Bitmap.FromStream(model.Image.InputStream));
}
else
{
await GroupManager.CreateAsync(group);
}
}
else
{
return(View(model));
}
// Than go to the groups view
return(RedirectToAction("Groups"));
}
public IActionResult Add(string returnUrl)
{
var model = new AddGroupViewModel()
{
returnUrl = returnUrl
};
return(View(model));
}
public ActionResult AddGroup()
{
ViewModels viewModel = new ViewModels();
AddGroupViewModel addGroup = new AddGroupViewModel();
KoloNaukowe group = new KoloNaukowe();
addGroup.Group = group;
viewModel.AddGroup = addGroup;
return(View(viewModel));
}
public async Task <IActionResult> AddGroup(AddGroupViewModel viewModel, CancellationToken cancellationToken)
{
var account = await AccountProvider.GetAccountForCurrentUser(cancellationToken);
var group = new Group(viewModel.Name, account);
MailAppDbContext.Groups.Add(group);
await MailAppDbContext.SaveChangesAsync(cancellationToken);
return(RedirectToAction(nameof(Details), new { groupId = group.Id }));
}
public ActionResult AddGroup(AddGroupViewModel model)
{
Groups newGroup = new Groups();
newGroup.Name = model.Name;
newGroup.CreationDate = DateTime.Now;
_unitOfWork.Groups.Add(newGroup);
_unitOfWork.Save();
return(RedirectToAction("GetGroups"));
}
public async Task <IActionResult> AddGroup(int id)
{
var groups = await this.groupsService.GetAll <GroupDropDownViewModel>().ToListAsync();
var viewModel = new AddGroupViewModel
{
Id = id,
Groups = groups,
};
return(this.View(viewModel));
}
public async Task <IActionResult> Add(AddGroupViewModel model)
{
ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User);
if (!ModelState.IsValid)
{
return(View(model));
}
Group group = new Group(model.Name);
_repository.AddGroup(group, Guid.Parse(user.Id));
return(RedirectToAction("Index"));
}
public async Task <ActionResult> AddGroup(AddGroupViewModel model)
{
if (ModelState.IsValid)
{
await _groupAdminService.AddGroupAsync(new AddGroupRequest
{
Number = model.Number,
Title = model.Title
});
return(RedirectToAction("Index"));
}
return(View(model));
}
public ActionResult AddGroup(AddGroupViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var group = new Group
{
GroupName = model.GroupName
};
var db = new ApplicationDbContext();
db.Groups.Add(group);
db.SaveChanges();
return(RedirectToAction("ManageGroups", new { Message = ForumMessageId.AddGroupSuccess }));
}
public ActionResult Add()
{
var users = Core.GetUsers();
var postedViewModel = ViewData.Model == null ? null : (AddGroupViewModel)ViewData.Model;
var viewModel = new AddGroupViewModel
{
Users = users.Items.Select(u => new GroupMemberViewModel
{
Id = u.Id,
Name = u.FullName,
Selected = postedViewModel != null && postedViewModel.Users.Any(user => u.Id == user.Id)
})
};
return(View(viewModel));
}
public async Task <ActionResult> AddGroup(AddGroupViewModel model)
{
if (ModelState.IsValid)
{
Stream thisStream = db.Streams.Find(model.StreamId);
Group thisGroup = db.Groups.Find(model.GroupId);
if (thisStream.Groups != null)
{
thisStream.Groups.Add(thisGroup);
}
thisStream.Groups = new List <Group> {
thisGroup
};
await db.SaveChangesAsync();
return(RedirectToAction("Details", new { id = thisStream.Id }));
}
return(View(model));
}
public async Task <IActionResult> AddGroup(AddGroupViewModel model)
{
ViewBag.Department = context.Departments.Select(c => new SelectListItem
{
Text = c.Name,
Value = c.Name
});
if (ModelState.IsValid)
{
var dep = context.Departments.Where(s => s.Name == model.DepartmentValue).FirstOrDefault();
var group = new Group()
{
Name = model.Name,
Email = model.Email,
Description = model.Description,
Department = dep
};
await context.Groups.AddAsync(group);
int changesCount = await context.SaveChangesAsync();
if (changesCount > 0)
{
var appLogType = context.AppLogTypes.Where(c => c.TypeName == "GroupAdded").FirstOrDefault();
var appLog = new AppLog()
{
Created = DateTime.Now,
AppLogType = appLogType,
Message = $"Добавлена новая группа. ID: {group.Id}, Наименование: {group.Name}"
};
await context.AppLogs.AddAsync(appLog);
await context.SaveChangesAsync();
}
return(RedirectToAction("Index", "Group"));
}
return(View());
}
public async Task <IActionResult> AddGroup(AddGroupViewModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
try
{
var id = await this.groupsService.AddGroupAsync(input.Id, input.GroupId);
this.TempData["Success"] = AddGroupSuccessMessage;
return(this.Redirect("/Concerts/Details/" + id));
}
catch (Exception e)
{
this.TempData["Error"] = e.Message;
return(this.RedirectToAction(nameof(this.AddGroup)));
}
}
public IActionResult Add(AddGroupViewModel model)
{
if (ModelState.IsValid)
{
bool check = repository.Groups.Any(x => x.GroupName == model.GroupName);
if (check)
{
ModelState.AddModelError("", $"Group with name {model.GroupName} is alredy exist.");
}
else
{
Group group = new Group {
GroupName = model.GroupName, Description = model.Description, YearOfStudy = model.YearOfStudy
};
repository.SaveGroup(group);
return(RedirectToAction(nameof(List)));
}
}
return(View(model));
}
public ActionResult Add(AddGroupViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(RedirectWithViewModel(viewModel, "add"));
}
var result = _addGroupCommand.Invoke(new AddGroupRequest
{
Name = viewModel.Name,
Organisation = Core.AppContext.CurrentUser.ActiveOrganisation,
Users = viewModel.Users.Where(user => user.Selected).Select(user => user.Id).ToList()
});
if (result.Status != AddGroupStatus.Ok)
{
return(RedirectWithViewModel(viewModel, "add", result.Status.MapToResource(Resources.Account.ResourceManager)));
}
return(Redirect(Url.Groups()));
}
public ActionResult EditGroup(AddGroupViewModel model)
{
var group = unitOfWork.GroupRepository.GetByID(model.groupid);
if (group == null)
{
AddApplicationMessage("Skupina nebyla nalezena", MessageSeverity.Danger);
}
else
{
group.Name = model.name;
group.Playoff = model.playoff ? 1 : 0;
unitOfWork.GroupRepository.Update(group);
unitOfWork.Save();
Log(JsonConvert.SerializeObject(model), LogEvent.GroupEdit.ToString(), group.ID, "group");
AddApplicationMessage("Skupina byla upravena", MessageSeverity.Success);
}
model.competition = group.Competitions;
return(RedirectToAction("Admin", "Competitions"));
}
public ActionResult AddGroup(int?compid)
{
if (compid == null)
{
AddApplicationMessage("Nebyl uveden identifikátor soutěže", MessageSeverity.Danger);
return(RedirectToAction("Admin", "Competitions"));
}
var comp = unitOfWork.CompetitionRepository.GetByID(compid);
if (comp == null)
{
AddApplicationMessage("Id neodpovídá žádné soutěži", MessageSeverity.Danger);
return(RedirectToAction("Admin", "Competitions"));
}
var model = new AddGroupViewModel()
{
competition = comp
};
return(View(model));
}
public ActionResult AddGroup(AddGroupViewModel model)
{
if (ModelState.IsValid)
{
var group = new Groups()
{
Competition = model.compid,
Name = model.name,
Playoff = model.playoff ? 1 : 0
};
unitOfWork.GroupRepository.Insert(group);
unitOfWork.Save();
Log(JsonConvert.SerializeObject(model), LogEvent.GroupAdd.ToString(), group.ID, "group");
AddApplicationMessage("Skupina byla přidána", MessageSeverity.Success);
return(RedirectToAction("Admin", "Competitions"));
}
model.competition = unitOfWork.CompetitionRepository.GetByID(model.compid);
AddApplicationMessage("Skupinu se nepodařilo uložit, zkontrolujte formulář", MessageSeverity.Danger);
return(View(model));
}
public EditGroupCommand(AddGroupViewModel vm)
{
_vm = vm;
}
public AddGroupUserControl(GroupView groupView)
{
ViewModel = new AddGroupViewModel(groupView);
InitializeComponent();
}
public AddGroupPage()
{
InitializeComponent();
BindingContext = new AddGroupViewModel();
}
public async Task <IActionResult> AddGroup(AddGroupViewModel model)
{
return(Ok());
}
public async Task Create([FromBody] AddGroupViewModel model)
{
await _service.Create(model);
}
public CreateGroupCommand(AddGroupViewModel vm)
{
_vm = vm;
}
//GET: Forum/AddGroup
public ActionResult AddGroup()
{
var model = new AddGroupViewModel();
return(View(model));
}
