private void DisplayAddGroup(GroupRequestModel model)
{
try
{
var newNode = new TreeViewItem();
newNode.Header = model.GroupName;
newNode.Tag = NodeType.Group;
var node = treeGroup.SelectedItem as TreeViewItem;
if ((NodeType)node.Tag == NodeType.Server)
{
node.Items.Add(newNode);
node.IsExpanded = true;
}
else
{
var parent = node.Parent as TreeViewItem;
parent.Items.Add(newNode);
parent.IsExpanded = true;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Info", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
public byte[] GetGroupLogo(GroupRequestModel model)
{
byte[] byteImage = null;
using (OrgCommEntities dbc = new OrgCommEntities(DBConfigs.OrgCommConnectionString))
{
var qry = dbc.Groups.AsQueryable();
byte[] logo = null;
if (model.Id.HasValue)
{
logo = qry.Where(r => (r.Id == model.Id.Value)).Select(r => r.Logo).FirstOrDefault();
}
else
{
throw new OrgException("Invalid id");
}
if (logo == null)
{
throw new OrgException("Logo not found");
}
else
{
return(logo);
}
}
}
private void mnuAddGroup_Click(object sender, RoutedEventArgs e)
{
try
{
var dlg = new dlgInputDialog("Please input Group name:", "");
if (dlg.ShowDialog() == false)
{
return;
}
if (dlg.Answer == "")
{
throw new Exception("Please input Group name");
}
var node = treeGroup.SelectedItem as TreeViewItem;
var group = new GroupRequestModel();
group.RequestType = RequestType.AddGroup;
group.GroupName = dlg.Answer;
if ((NodeType)node.Tag == NodeType.Server)
{
group.ServerName = node.Header.ToString();
}
else
{
var parent = node.Parent as TreeViewItem;
group.ServerName = parent.Header.ToString();
}
_opcService.AddGroup(group);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Info", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
public async Task <GroupResponseModel> PutGroup(
int groupId,
[FromForm] GroupRequestModel model,
CancellationToken cancellationToken
)
{
cancellationToken.ThrowIfCancellationRequested();
var command = new UpdateGroupCommand(
groupId,
model.Name,
model.FacultyId,
model.CourseNumber
);
await _mediator.Send(command, cancellationToken);
var query = new FindGroupByIdQuery(groupId);
var group = await _mediator.Send(query, cancellationToken);
var response = _mapper.Map <GroupResponseModel>(group);
return(response);
}
public async Task <ServiceResult <int> > CreateAsync(User admin, GroupRequestModel group)
{
if (groupsRepository.GetGroupsCount(group.Name) != 0)
{
return(ServiceResult <int> .Error(400, "Group already exists"));
}
var groupEntity = new Group()
{
Name = group.Name,
Balance = 0.0M,
GroupCode = Math.Abs(group.Name.GetHashCode()).ToString(),
AdminId = admin.Id
};
var result = await groupsRepository.CreateAsync(groupEntity);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Error creating group"));
}
var addedUser = await groupUsersService.AddUser(result.GroupCode, admin);
if (addedUser is null)
{
return(ServiceResult <int> .Error(500, "Error creating adding user to group"));
}
result.Admin = admin;
result.AdminId = admin.Id;
return(ServiceResult <int> .Success(GroupViewModel.FromModel(result)));
}
public async Task<GroupResponseModel> Put(string orgId, string id, [FromBody] GroupRequestModel model)
{
var group = await _groupRepository.GetByIdAsync(new Guid(id));
if (group == null || !await _currentContext.ManageGroups(group.OrganizationId))
{
throw new NotFoundException();
}
await _groupService.SaveAsync(model.ToGroup(group), model.Collections?.Select(c => c.ToSelectionReadOnly()));
return new GroupResponseModel(group);
}
public async Task <IActionResult> UpdateAsync(int id, [FromBody] GroupRequestModel group)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await groupsService.Update(User, id, group);
return(HandlePutResult(result));
}
public async Task <ActionResult> Edit(int id, GroupRequestModel model)
{
var group = this.mapper.Map <Group>(model);
var result = await this.groupService.EditAsync(id, group);
if (result.Succeeded)
{
return(Ok(group.Id));
}
return(BadRequest(result.Errors));
}
public async Task<GroupResponseModel> Post(string orgId, [FromBody] GroupRequestModel model)
{
var orgIdGuid = new Guid(orgId);
if (!await _currentContext.ManageGroups(orgIdGuid))
{
throw new NotFoundException();
}
var group = model.ToGroup(orgIdGuid);
await _groupService.SaveAsync(group, model.Collections?.Select(c => c.ToSelectionReadOnly()));
return new GroupResponseModel(group);
}
public async Task <IActionResult> CreateAsync([FromBody] GroupRequestModel group)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var admin = await usersManager.FindByNameAsync(User.Identity?.Name);
var result = await groupsService.CreateAsync(admin, group);
return(HandlePostResult("groups", result));
}
public bool RemoveGroup(GroupRequestModel model)
{
try
{
var jsontext = JsonConvert.SerializeObject(model);
WriteValue(jsontext);
return(true);
}
catch (Exception)
{
return(false);
}
}
public bool ResponseRemoveGroup(GroupRequestModel model)
{
try
{
model.RequestType = RequestType.RemoveGroup;
var jsonText = JsonConvert.SerializeObject(model);
WriteValue(jsonText);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public bool ReadGroupTags(GroupRequestModel group)
{
try
{
group.RequestType = RequestType.ReadGroupTags;
var jsontext = JsonConvert.SerializeObject(group);
WriteValue(jsontext);
return(true);
}
catch (Exception)
{
return(false);
}
}
private void mnuRemoveGroup_Click(object sender, RoutedEventArgs e)
{
try
{
var node = treeGroup.SelectedItem as TreeViewItem;
var group = new GroupRequestModel();
group.RequestType = RequestType.RemoveGroup;
group.GroupName = node.Header.ToString();
var parent = node.Parent as TreeViewItem;
group.ServerName = parent.Header.ToString();
_opcService.RemoveGroup(group);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Info", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
private void DisplayRemoveGroup(GroupRequestModel model)
{
try
{
var node = treeGroup.SelectedItem as TreeViewItem;
var parent = node.Parent as TreeViewItem;
parent.Items.Remove(node);
if (_listTags != null)
{
_listTags.Clear();
lvTag.Items.Refresh();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Info", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
public async Task <ActionResult> Add(GroupRequestModel model)
{
var group = this.mapper.Map <Group>(model);
var user = await this.userManager.FindByIdAsync(this.User.FindFirstValue(ClaimTypes.NameIdentifier));
group.User = user;
if (user == null)
{
return(Unauthorized());
}
var result = await this.groupService.Add(group);
if (result.Succeeded)
{
return(Created(nameof(this.Add), group.Id));
}
return(BadRequest(result.Errors));
}
private void treeGroup_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (e.NewValue == null)
{
return;
}
var node = e.NewValue as TreeViewItem;
//node group
if ((NodeType)node.Tag == NodeType.Group)
{
var nParent = node.Parent as TreeViewItem;
var group = new GroupRequestModel()
{
RequestType = RequestType.ReadGroupTags,
ServerName = nParent.Header.ToString(),
GroupName = "" + node.Header
};
_opcService.ReadGroupTags(group);
}
SetEnable_TreeMenu();
}
public async Task <ServiceResult <int> > Update(ClaimsPrincipal user, int id, GroupRequestModel group)
{
var groupEntity = groupsRepository.Get(id);
if (groupEntity is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, groupEntity, GroupOperations.Write);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
groupEntity.Name = group.Name;
var result = await groupsRepository.UpdateAsync(groupEntity);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Could not update group"));
}
return(ServiceResult <int> .Success(GroupViewModel.FromModel(result)));
}
