public IActionResult CreateGroup([FromBody] GroupForCreationDto groupDto)
{
if (groupDto == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var groupEntity = Mapper.Map <Entities.Group>(groupDto);
_registrationRepository.AddGroup(groupEntity);
if (!_registrationRepository.Save())
{
return(StatusCode(500, "A problem happened while handling your request."));
}
var createdGroupToReturn = Mapper.Map <GroupDto>(groupEntity);
return(CreatedAtRoute("GetGroup", new
{ id = createdGroupToReturn.Id }, createdGroupToReturn));
}
public async Task <IActionResult> CreateGroup(/*int userId, */ [FromBody] GroupForCreationDto groupForCreationDto)
{
List <User> volunteers = new List <User>();
foreach (var volIds in groupForCreationDto.VolunteerIds)
{
var volunteer = await _repo.GetUser(volIds);
volunteers.Add(volunteer);
}
List <User> students = new List <User>();
foreach (var studIds in groupForCreationDto.StudentIds)
{
var student = await _repo.GetUser(studIds);
students.Add(student);
}
Group newGroup = new Group();
newGroup.StudentLevel = students[0].StudentLevel;
_repo.Add(newGroup);
foreach (var user in volunteers)
{
UserGroup userGroup = new UserGroup
{
// User = user,
UserId = user.Id,
// Group = newGroup,
GroupId = newGroup.Id
};
_repo.Add(userGroup);
}
foreach (var user in students)
{
UserGroup userGroup = new UserGroup
{
// User = user,
UserId = user.Id,
// Group = newGroup,
GroupId = newGroup.Id
};
_repo.Add(userGroup);
}
if (await _repo.SaveAll())
{
return(Ok(newGroup));
}
throw new Exception("Creating the assignment failed on save");
}
public bool CreateConnections(GroupForCreationDto groupForCreationDto, ref List <Exception> excepts)
{
Calculator calculator = new Calculator();
CloudmonkeyParser jsonParser = new CloudmonkeyParser();
GuacamoleDatabaseInserter inserter = new GuacamoleDatabaseInserter();
ScriptExecutor executor = new ScriptExecutor();
string connectionName, templateInfo, templateId, zoneInfo, zoneId, serviceOfferingInfo, serviceOfferingId;
using (Formatter styler = new Formatter())
{
connectionName = styler.FormatVmName(groupForCreationDto.Name, ref excepts);
if (connectionName == null)
{
return(false);
}
}
//Get the virtual machine template information
templateInfo = executor.GetTemplateStats();
templateId = jsonParser.ParseTemplateId(templateInfo, groupForCreationDto.VMChoice);
Console.WriteLine(templateId);
//Get the virtual machine service offering info
serviceOfferingInfo = executor.GetServiceOfferingStats();
serviceOfferingId = jsonParser.ParseServiceOfferingId(serviceOfferingInfo, groupForCreationDto.Memory);
Console.WriteLine(serviceOfferingId);
//Get the zone information
zoneInfo = executor.GetZoneStats();
zoneId = jsonParser.ParseZoneId(zoneInfo);
Console.WriteLine(zoneId);
for (int i = 0; i < groupForCreationDto.MinVms; i++)
{
//Deploy the new virtual machine
string vmInfo = executor.DeployVirtualMachine(connectionName, templateId, serviceOfferingId, zoneId);
string vmId = jsonParser.ParseVmId(vmInfo);
Console.WriteLine(vmId);
//Accquire a public ip address for the virtual machine
string associatedIpInfo = executor.AccquireIp();
string associatedIp = jsonParser.ParseAssociatedIpInfo(associatedIpInfo);
string associatedIpId = jsonParser.ParseAssociatedIpId(associatedIpInfo);
Console.WriteLine(associatedIp);
Console.WriteLine(associatedIpId);
//Setup the static nat for the accquired vm and ip
Console.WriteLine(executor.SetStaticNat(vmId, associatedIpId));
if (!inserter.InsertConnection(groupForCreationDto.Name, connectionName, associatedIp,
groupForCreationDto.Protocol, ref excepts))
{
return(false);
}
}
return(true);
}
public async Task <IActionResult> CreateGroup(int userId, [FromForm] GroupForCreationDto group)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
return(Ok(await _groupsService.CreateGroup(userId, group)));
}
public IActionResult AddGroup([FromBody] GroupForCreationDto groupFromBody)
{
if (_groupService.checkIfNameAlreadyExists(groupFromBody))
{
return(BadRequest("Grupa o podanej nazwie już istnieje. Podaj inną nazwę."));
}
var groupToReturn = _groupService.AddGroup(groupFromBody);
return(Created(nameof(GetGroups), groupToReturn));
}
public async Task CreateGroup_ShouldReturnTrue_WhenLocationDoesntExist_AndIsCompleted()
{
// Arrange
var expectedMessage = "Group created successfully!";
var groupDto = new GroupForCreationDto()
{
Image = null,
};
var powerUser = new PowerUser()
{
Id = 1
};
var group = new Group()
{
Id = 1,
Image = null
};
var membership = new Membership()
{
UserId = powerUser.Id,
Accepted = true,
Favorite = true,
Group = null,
Role = Role.Member,
User = powerUser,
DateAccepted = DateTime.Now,
DateSent = DateTime.Now,
GroupId = group.Id,
MembershipStatus = MembershipStatus.Sent
};
_unitOfWork.Setup(x => x.Users.GetById(It.IsAny <int>()))
.ReturnsAsync(powerUser);
_mapperMock.Setup(x => x.Map <Group>(It.IsAny <GroupForCreationDto>()))
.Returns(group);
_unitOfWork.Setup(x => x.Locations.GetByName(It.IsAny <string>()))
.ReturnsAsync(() => null);
_unitOfWork.Setup(x => x.Groups.Add(group)).Verifiable();
_unitOfWork.Setup(x => x.Complete()).ReturnsAsync(true);
_unitOfWork.Setup(x => x.Memberships.Add(membership)).Verifiable();
// Act
var result = await _sut.CreateGroup(It.IsAny <int>(), groupDto);
// Assert
Assert.True(result.Key);
Assert.Equal(expectedMessage, result.Value);
}
/// <summary>
/// Validates the input for the list of dawgtags.
/// </summary>
/// <returns><c>true</c>, if the dawgtags were valid, <c>false</c> otherwise.</returns>
/// <param name="groupForCreationDto">Group for creation dto.</param>
/// <param name="excepts">Excepts.</param>
protected bool ValidateInputForUsers(GroupForCreationDto groupForCreationDto, ref List <Exception> excepts)
{
using (Validator checker = new Validator())
{
//Check if the dawgtags are in the proper format
foreach (string dawgtag in groupForCreationDto.Dawgtags)
{
checker.ValidateDawgtag(dawgtag, ref excepts);
}
}
return(excepts.Count == 0);
}
public GroupDto AddGroup(GroupForCreationDto group)
{
var groupToSave = Mapper.Map <Group>(group);
_dbContext.Groups.Add(groupToSave);
if (_dbContext.SaveChanges() == 0)
{
throw new Exception("Could not add group");
}
return(Mapper.Map <GroupDto>(groupToSave));
}
/// <summary>
/// Validates the user input for group parameters.
/// </summary>
/// <returns><c>true</c>, if input parameters for the group is valid, <c>false</c> otherwise.</returns>
/// <param name="groupForCreationDto">Group for creation dto.</param>
/// <param name="excepts">Excepts.</param>
protected bool ValidateInputForNewGroup(GroupForCreationDto groupForCreationDto, ref List <Exception> excepts)
{
using (Validator checker = new Validator())
{
//Check if the group inupt parameters are valid
checker.ValidateNewGroupName(groupForCreationDto.Name, ref excepts);
checker.ValidateConnectionType(groupForCreationDto.VMChoice, ref excepts);
checker.ValidateMin(groupForCreationDto.MinVms, ref excepts);
checker.ValidateMax(groupForCreationDto.MaxVms, ref excepts);
checker.ValidateMinMax(groupForCreationDto.MinVms, groupForCreationDto.MaxVms, ref excepts);
checker.ValidateHotspares(groupForCreationDto.NumHotspares, ref excepts);
}
return(excepts.Count == 0);
}
/// <summary>
/// Formats the given user inputs to ensure data consistancy when stored.
/// </summary>
/// <returns><c>true</c>, if the input was formated, <c>false</c> otherwise.</returns>
/// <param name="groupForCreationDto">Group for creation dto.</param>
/// <param name="excepts">Excepts.</param>
protected bool FormatInput(GroupForCreationDto groupForCreationDto, ref List <Exception> excepts)
{
// Format User Text Input to be standardized to the following:
//EX. test_group_1, ubuntu_16.04
using (Formatter styler = new Formatter())
{
groupForCreationDto.Name = styler.FormatGroupName(groupForCreationDto.Name);
groupForCreationDto.Protocol = styler.FormatName(groupForCreationDto.Protocol);
for (int i = 0; i < groupForCreationDto.Dawgtags.Count; i++)
{
groupForCreationDto.Dawgtags = styler.FormatDawgtagList(groupForCreationDto.Dawgtags);
}
}
return(true);
}
public ActionResult CreateGroup(GroupForCreationDto groupForCreationDto)
{
//Method Level Variable Declarations
List <Exception> excepts = new List <Exception>();
//Check if the group inupt parameters are valid
using (Validator checker = new Validator())
{
checker.ValidateGroupName(groupForCreationDto.Name, ref excepts);
checker.ValidateVmTotal(groupForCreationDto.Max, ref excepts);
}
if (excepts.Count != 0)
{
var message = HandleErrors(excepts);
return(Ok(null));
}
//Format connection group type
using (Formatter styler = new Formatter())
{
groupForCreationDto.Type = styler.FormatName(groupForCreationDto.Type);
}
//Get affinity bool
string affinityBool = "0";
if (groupForCreationDto.Affinity)
{
affinityBool = "1";
}
//Create connection group
GuacamoleDatabaseInserter inserter = new GuacamoleDatabaseInserter();
if (!inserter.InsertConnectionGroup(groupForCreationDto.Name, groupForCreationDto.Type, groupForCreationDto.Max, affinityBool, ref excepts))
{
var message = HandleErrors(excepts);
return(Ok(null));
}
//Get the newly created group id
GuacamoleDatabaseGetter getter = new GuacamoleDatabaseGetter();
groupForCreationDto.Id = getter.GetConnectionGroupId(groupForCreationDto.Name, ref excepts);
return(Ok(groupForCreationDto));
}
public JsonResult CreationGroup([FromBody] GroupForCreationDto group)
{
string functionName = System.Reflection.MethodBase.GetCurrentMethod().Name;
try
{
AccountEntity account = _accountRepository.GetAccountById(group.accountId); //get account from AccountController stored data user logged in
if (group == null)
{
Log4Net.log.Error(className + "." + functionName + " - " + Log4Net.AddErrorLog(Constants.notInformationGroup));
return(Json(MessageResult.GetMessage(MessageType.NOT_INFORMATION_GROUP)));
}
//This is get current day
group.CreatedDate = DateTime.Now;
if (!ModelState.IsValid)
{
Log4Net.log.Error(className + "." + functionName + " - " + Log4Net.AddErrorLog(Constants.notFound));
return(Json(MessageResult.GetMessage(MessageType.NOT_FOUND)));
}
var finalGroup = Mapper.Map <PPT.Database.Entities.GroupEntity>(group);
//This is query insert account
_groupRepository.CreationGroup(finalGroup, account);
if (!_groupRepository.Save())
{
Log4Net.log.Error(className + "." + functionName + " - " + Log4Net.AddErrorLog(Constants.badRequest));
return(Json(MessageResult.GetMessage(MessageType.BAD_REQUEST)));
}
Log4Net.log.Error(className + "." + functionName + " - " + Log4Net.AddErrorLog(Constants.groupCreated));
return(Json(MessageResult.GetMessage(MessageType.GROUP_CREATED)));
}
catch (Exception ex)
{
Log4Net.log.Error(className + "." + functionName + " - " + Log4Net.AddErrorLog(ex.Message));
return(Json(MessageResult.ShowServerError(ex.Message)));
}
}
public async Task CreateGroup_ShouldReturnFalse_WhenLocationDoesntExist_AndIsNotCompleted()
{
// Arrange
var expectedMessage = "Couldn't create group";
var groupDto = new GroupForCreationDto()
{
Image = null,
};
var powerUser = new PowerUser()
{
Id = 1
};
var group = new Group()
{
Id = 1,
Image = null
};
_unitOfWork.Setup(x => x.Users.GetById(It.IsAny <int>()))
.ReturnsAsync(powerUser);
_mapperMock.Setup(x => x.Map <Group>(It.IsAny <GroupForCreationDto>()))
.Returns(group);
_unitOfWork.Setup(x => x.Locations.GetByName(It.IsAny <string>()))
.ReturnsAsync(() => null);
_unitOfWork.Setup(x => x.Groups.Add(group)).Verifiable();
_unitOfWork.Setup(x => x.Complete()).ReturnsAsync(false);
// Act
var result = await _sut.CreateGroup(It.IsAny <int>(), groupDto);
// Assert
Assert.False(result.Key);
Assert.Equal(expectedMessage, result.Value);
}
protected bool CreateConnection(GroupForCreationDto groupForCreationDto, ref List <Exception> excepts)
{
Calculator calculator = new Calculator();
GuacamoleDatabaseInserter inserter = new GuacamoleDatabaseInserter();
string connectionName;
using (Formatter styler = new Formatter())
{
connectionName = styler.FormatVmName(groupForCreationDto.Name, ref excepts);
if (connectionName == null)
{
return(false);
}
}
if (inserter.InsertConnection(groupForCreationDto.Name, connectionName, calculator.GetNextIp(),
groupForCreationDto.Protocol, ref excepts))
{
return(true);
//return InitializeConnection(groupForCreationDto, ref excepts);
}
return(false);
}
public void CreateGroup(string userId, GroupForCreationDto groupForCreationDto)
{
//Method Level Variable Declarations
List <Exception> excepts = new List <Exception>();
//Format the given input
if (!FormatInput(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return; //BadRequest(message);
}
//Validate group input parameters
if (!ValidateInputForNewGroup(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return; //BadRequest(message);
}
//Validate user input parameters
if (!ValidateInputForUsers(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return; //BadRequest(message);
}
//Create user group
if (!CreateUserGroup(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return; //BadRequest(message);
}
//Create users if they do not exist in the system and add them to the
//created user group
foreach (string dawgtag in groupForCreationDto.Dawgtags)
{
//Verify a user exists and create them if they do not
if (InitializeUser(dawgtag, ref excepts))
{
AddUserToUserGroup(groupForCreationDto.Name, dawgtag, ref excepts);
}
}
//Create Connection Group
if (!CreateConnectionGroup(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return; //BadRequest(message);
}
//Connect the user group to the connection group
if (!AddConnectionGroupToUserGroup(groupForCreationDto.Name, ref excepts))
{
var message = HandleErrors(excepts);
return; //BadRequest(message);
}
//Create the minimum desired Connections
if (!CreateConnections(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return; //BadRequest(message);
}
//return Ok();
}
public async Task <KeyValuePair <bool, string> > CreateGroup(int userId, GroupForCreationDto group)
{
// Groups and User relationship is based on Membership so
// when we add group we need to add new Membership with desired user
var user = await _unitOfWork.Users.GetById(userId);
if (user == null)
{
return(new KeyValuePair <bool, string>(false, "User doesn't exist!"));
}
if (!(user is PowerUser))
{
return(new KeyValuePair <bool, string>(false, "Unauthorized"));
}
PowerUser powerUser = (PowerUser)user;
var groupToAdd = _mapper.Map <Group>(group);
if (group.Image != null)
{
if (ImageValidator.ImageExtensionValidation(group.Image.FileName) &&
ImageValidator.ImageSizeValidation(group.Image.Length) &&
ImageValidator.ImageSignatureValidation(group.Image))
{
using (var memoryStream = new MemoryStream())
{
await group.Image.CopyToAsync(memoryStream);
groupToAdd.Image = memoryStream.ToArray();
}
}
else
{
return(new KeyValuePair <bool, string>(false, "Image cannot be uploaded"));
}
}
// We check if selected location exists
// If it doesn't we create a new one with specified country and city
var location = await _unitOfWork.Locations.GetByName(groupToAdd.Name);
if (location == null)
{
location = new Location {
Name = group.Location, CityId = group.CityId, CountryId = group.CountryId
};
_unitOfWork.Locations.Add(location);
}
groupToAdd.CreatedBy = powerUser;
groupToAdd.Location = location;
powerUser.NumberOfGroupsCreated += 1;
_unitOfWork.Groups.Add(groupToAdd);
if (!await _unitOfWork.Complete())
{
return(new KeyValuePair <bool, string>(false, "Couldn't create group"));
}
var membership = new Membership {
UserId = powerUser.Id, GroupId = groupToAdd.Id, DateSent = DateTime.Now, Role = Role.Owner, Accepted = true, DateAccepted = DateTime.Now, User = powerUser, Group = groupToAdd, MembershipStatus = MembershipStatus.Accepted
};
_unitOfWork.Memberships.Add(membership);
if (await _unitOfWork.Complete())
{
return(new KeyValuePair <bool, string>(true, "Group created successfully!"));
}
return(new KeyValuePair <bool, string>(false, "Something went wrong!"));
}
public async Task <IActionResult> CreateGroup(GroupForCreationDto groupForCreationDto)
{
//Method Level Variable Declarations
List <Exception> excepts = new List <Exception>();
//Format the given input
if (!FormatInput(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return(BadRequest(message));
}
//Validate group input parameters
if (!ValidateInputForNewGroup(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return(BadRequest(message));
}
//Validate user input parameters
if (!ValidateInputForUsers(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return(BadRequest(message));
}
//Create user group
if (!CreateUserGroup(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return(BadRequest(message));
}
//Create users if they do not exist in the system and add them to the
//created user group
foreach (string dawgtag in groupForCreationDto.Dawgtags)
{
//Verify a user exists and create them if they do not
if (InitializeUser(dawgtag, ref excepts))
{
AddUserToUserGroup(groupForCreationDto.Name, dawgtag, ref excepts);
}
}
//Create Connection Group
if (!CreateConnectionGroup(groupForCreationDto, ref excepts))
{
var message = HandleErrors(excepts);
return(BadRequest(message));
}
//Connect the user group to the connection group
if (!AddConnectionGroupToUserGroup(groupForCreationDto.Name, ref excepts))
{
var message = HandleErrors(excepts);
return(BadRequest(message));
}
//Create the minimum desired Connections
//for(int i = 0; i < groupForCreationDto.MaxVms; i++)
//{
CreateConnection(groupForCreationDto, ref excepts);
//}
if (excepts.Count != 0)
{
var message = HandleErrors(excepts);
return(BadRequest(message));
}
return(Ok());
}
/// <summary>
/// Creates the new connection group.
/// </summary>
/// <returns><c>true</c>, if the connection group was created, <c>false</c> otherwise.</returns>
/// <param name="groupForCreationDto">Group for creation dto.</param>
/// <param name="excepts">Excepts.</param>
private bool CreateConnectionGroup(GroupForCreationDto groupForCreationDto, ref List <Exception> excepts)
{
GuacamoleDatabaseConnectionFacade.GuacamoleDatabaseConnectors.GuacamoleDatabaseInserter inserter = new GuacamoleDatabaseConnectionFacade.GuacamoleDatabaseConnectors.GuacamoleDatabaseInserter();
return(inserter.InsertConnectionGroup(groupForCreationDto.Name, groupForCreationDto.MaxVms, ref excepts));
}
/// <summary>
/// Creates the new user group.
/// </summary>
/// <returns><c>true</c>, if user group was created, <c>false</c> otherwise.</returns>
/// <param name="groupForCreationDto">Group for creation dto.</param>
/// <param name="excepts">Excepts.</param>
private bool CreateUserGroup(GroupForCreationDto groupForCreationDto, ref List <Exception> excepts)
{
GuacamoleDatabaseInserter inserter = new GuacamoleDatabaseInserter();
return(inserter.InsertUserGroup(groupForCreationDto.Name, ref excepts));
}
public bool checkIfNameAlreadyExists(GroupForCreationDto group)
{
return(_dbContext.Groups.Any(g => g.Name == group.Name));
}
