public Group GetGroup(GroupId groupId)
{
Silanis.ESL.API.Group apiGroup = apiClient.GetGroup(groupId.Id);
Group sdkGroup = new GroupConverter(apiGroup).ToSDKGroup();
return(sdkGroup);
}
public Group GetGroup(GroupId groupId)
{
OneSpanSign.API.Group apiGroup = apiClient.GetGroup(groupId.Id);
Group sdkGroup = new GroupConverter(apiGroup).ToSDKGroup();
return(sdkGroup);
}
public Group UpdateGroup(Group group, GroupId groupId)
{
Silanis.ESL.API.Group apiGroup = new GroupConverter(group).ToAPIGroup();
apiGroup = apiClient.UpdateGroup(apiGroup, groupId.Id);
Group sdkGroup = new GroupConverter(apiGroup).ToSDKGroup();
return(sdkGroup);
}
public async Task <GroupDto> GetGroupByIdAsync(Guid id)
{
GroupDto group = GroupConverter.Convert(await _groupRepo.GetByIdAsync(id));
group.CourseName = _courseRepo.GetByIdAsync(group.CourseId).Result.Name;
group.Participant = ParticipantConverter.Convert(await _participantRepo.GetByGroupIdAsync(id));
return(group);
}
public async Task GetUserGroups()
{
var user = fillTestDbHelper.Users.FirstOrDefault();
var expectedGroups = GroupConverter.GetGroupsDto(fillTestDbHelper.Groups.Where(opt => opt.UserId == user.Id).ToList());
var actualGroups = await groupsService.GetUserGroupsAsync(user.Id);
Assert.Equal(expectedGroups.Select(opt => opt.GroupId).OrderBy(opt => opt), actualGroups.Select(opt => opt.GroupId).OrderBy(opt => opt));
}
public Group CreateGroup( Group group ) {
Silanis.ESL.API.Group apiGroup = new GroupConverter( group ).ToAPIGroupWithoutMembers();
apiGroup = apiClient.CreateGroup( apiGroup );
Group sdkGroup = new GroupConverter( apiGroup ).ToSDKGroup();
foreach ( GroupMember groupMember in group.Members ) {
AddMember( sdkGroup.Id, groupMember );
}
return sdkGroup;
}
public override Message CreateTemplateDefinitionMessage(MessageTemplate messageTemplate)
{
Message templateDefinition = GroupConverter.Convert(messageTemplate, new Message(TemplateDefinition),
_initialContext);
int reset = messageTemplate.HasAttribute(ResetProperty) ? 1 : 0;
templateDefinition.SetInteger("Reset", reset);
return(templateDefinition);
}
public Group AddGroup([FromBody] Group group)
{
var participant1 = _participantService.LoadParticipantById(group.Participant1Id);
var participant2 = _participantService.LoadParticipantById(group.Participant2Id);
var newGroup = GroupConverter.ConvertDtoToModel(group, participant1, participant2);
newGroup = _groupService.AddGroup(newGroup);
return(GroupConverter.ConvertModelToDto(newGroup));
}
public async Task <CourseDto> GetCourseByIdAsync(Guid id)
{
CourseDto course = CourseConverter.Convert(await _courseRepo.GetByIdAsync(id));
course.DirectionName = _directionRepo.GetByIdAsync(course.DirectionId).Result.Name;
course.Groups = GroupConverter.Convert(await _groupRepo.GetByCourseIdAsync(id));
course.Pages = PageConverter.Convert(await _pageRepo.GetByCourseIdAsync(id));
return(course);
}
public Group UpdateGroup([FromBody] Group group)
{
var participant1 = _participantService.LoadParticipantById(group.Participant1Id);
var participant2 = _participantService.LoadParticipantById(group.Participant2Id);
var groupToUpdate = GroupConverter.ConvertDtoToModel(group, participant1, participant2);
groupToUpdate = _groupService.Update(groupToUpdate);
return(GroupConverter.ConvertModelToDto(groupToUpdate));
}
public async Task <List <GroupDto> > GetUserGroupsAsync(long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
var groups = await context.Groups.Where(opt => opt.UserId == userId).ToListAsync().ConfigureAwait(false);
return(GroupConverter.GetGroupsDto(groups));
}
}
public void UsesMultipleConverters()
{
var converter = new GroupConverter();
converter.Add(new MathOperationConverter(MathOperator.Add));
converter.Add(new MathOperationConverter(MathOperator.Subtract));
Assert.Equal(5, converter.Convert(5, typeof(int), 1, null));
}
public async Task RemoveUsersFromGroups()
{
var user = fillTestDbHelper.Users.Skip(1).FirstOrDefault();
var group = GroupConverter.GetGroupDto(user.Groups.FirstOrDefault());
await groupsService.RemoveUsersFromGroupsAsync(group.UsersId, group.GroupId, user.Id);
var actualGroup = GroupConverter.GetGroupDto(fillTestDbHelper.Groups.FirstOrDefault(opt => opt.GroupId == group.GroupId));
Assert.True(actualGroup.UsersId.IsNullOrEmpty());
}
public IEnumerable <Group> GetAllGroupsOfRace()
{
if (string.IsNullOrEmpty(CurrentContext.CurrentRaceTitle))
{
return(new List <Group>());
}
var allGroups = _raceService.LoadCurrentRace().Groups;
return(GroupConverter.ConvertModelToDto(allGroups));
}
public void Convert_SingleDimension_ToString()
{
//Arrange
var input = new uint[] { 1, 3, 3, 8, 1 };
IGroupConverter converter = new GroupConverter();
//Act
string result = converter.Convert(input);
//Assert
Assert.AreEqual("{1,3,3,8,1}", result);
}
public void Convert_TwoDimension_ToString()
{
//Arrange
var input = new[] { new GroupDescriptor(3, 2), new GroupDescriptor(4, 2) };
IGroupConverter converter = new GroupConverter();
//Act
string result = converter.Convert(input);
//Assert
Assert.AreEqual($"{{3,4}}{Environment.NewLine}{{4,5}}", result);
}
public void Parse_OneDimension_ToString()
{
//Arrange
string input = "{1 3 3 8 1}";
IGroupConverter converter = new GroupConverter();
//Act
IEnumerable <uint> result = converter.Parse(input);
//Assert
CollectionAssert.AreEqual(new uint[] { 1, 3, 3, 8, 1 }, result);
}
public IEnumerable <Group> GetAllAvailableGroups()
{
var allAvailableGroups = _groupService.LoadAllAvailableGroups();
if (allAvailableGroups is null)
{
return(GroupConverter.ConvertModelToDto(new List <Model.Group>()));
}
return(GroupConverter.ConvertModelToDto(allAvailableGroups));
}
public async Task <IActionResult> Put([FromBody] Group group)
{
if (group == null)
{
return(BadRequest());
}
await GroupRepository.UpdateAsync(GroupConverter.Convert(group));
return(new OkObjectResult(group));
}
public async Task <IActionResult> Get(int id)
{
var group = await GroupRepository.GetEntityAsync(id);
if (group == null)
{
return(NotFound());
}
return(new OkObjectResult(GroupConverter.Convert(group)));
}
public Group CreateGroup(Group group)
{
Silanis.ESL.API.Group apiGroup = new GroupConverter(group).ToAPIGroupWithoutMembers();
apiGroup = apiClient.CreateGroup(apiGroup);
Group sdkGroup = new GroupConverter(apiGroup).ToSDKGroup();
foreach (GroupMember groupMember in group.Members)
{
AddMember(sdkGroup.Id, groupMember);
}
return(sdkGroup);
}
public Group GetGroup( GroupId groupId ) {
string path = template.UrlFor (UrlTemplate.GROUPS_ID_PATH)
.Replace ("{groupId}", groupId.Id)
.Build ();
try {
string response = restClient.Get(path);
Silanis.ESL.API.Group apiGroup = JsonConvert.DeserializeObject<Silanis.ESL.API.Group> (response, settings);
Group sdkGroup = new GroupConverter( apiGroup ).ToSDKGroup();
return sdkGroup;
} catch (Exception e) {
throw new EslException ("Failed to retrieve group." + " Exception: " + e.Message);
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
var groupDto = await groupsService.CreateOrEditGroupAsync(GroupConverter.GetGroupDto(request.Group, clientConnection.UserId.GetValueOrDefault())).ConfigureAwait(false);
return(new GroupsResponse(request.RequestId, GroupConverter.GetGroupVm(groupDto)));
}
catch (ObjectDoesNotExistsException ex)
{
Logger.WriteLog(ex);
return(new ResultResponse(request.RequestId, "User not found.", ObjectsLibrary.Enums.ErrorCode.ObjectDoesNotExists));
}
}
public Group UpdateGroupToRace([FromBody] Group group)
{
var currentRace = _raceService.LoadCurrentRace();
var oldGroup = currentRace.Groups.SingleOrDefault(x => x.GroupId == group.GroupId);
if (oldGroup is null)
{
return(null);
}
var groupToUpdate = GroupConverter.ConvertDtoToModel(group, oldGroup.Participant1, oldGroup.Participant2);
_raceService.UpdateGroups(currentRace, groupToUpdate);
return(GroupConverter.ConvertModelToDto(groupToUpdate));
}
public Group GetGroup(GroupId groupId)
{
string path = template.UrlFor(UrlTemplate.GROUPS_ID_PATH)
.Replace("{groupId}", groupId.Id)
.Build();
try {
string response = restClient.Get(path);
Silanis.ESL.API.Group apiGroup = JsonConvert.DeserializeObject <Silanis.ESL.API.Group> (response, settings);
Group sdkGroup = new GroupConverter(apiGroup).ToSDKGroup();
return(sdkGroup);
} catch (Exception e) {
throw new EslException("Failed to retrieve group." + " Exception: " + e.Message);
}
}
public static string GetAllToolMarkdownDoc()
{
var sb = new StringBuilder();
var tools = PluginProvider.GetPluginCollection(typeof(IColumnProcess));
var groupConverter = new GroupConverter();
foreach (var toolgroup in tools.GroupBy(d => groupConverter.Convert(d, null, null, null)))
{
sb.Append(string.Format("# {0}\n", toolgroup.Key));
foreach (var tool in toolgroup)
{
sb.Append(GetMarkdownScript(tool.MyType, true));
}
}
return(sb.ToString());
}
public Group CreateGroup( Group group ) {
string path = template.UrlFor (UrlTemplate.GROUPS_PATH).Build ();
Silanis.ESL.API.Group apiGroup = new GroupConverter( group ).ToAPIGroupWithoutMembers();
try {
string json = JsonConvert.SerializeObject (apiGroup, settings);
string response = restClient.Post(path, json);
Silanis.ESL.API.Group apiResponse = JsonConvert.DeserializeObject<Silanis.ESL.API.Group> (response);
Group sdkGroup = new GroupConverter( apiResponse ).ToSDKGroup();
foreach ( GroupMember groupMember in group.Members ) {
InviteMember( sdkGroup.Id, groupMember );
}
return sdkGroup;
} catch (Exception e) {
throw new EslException ("Failed to create new group." + " Exception: " + e.Message);
}
}
public async Task <List <GroupDto> > GetGroupsAsync(List <Guid> groupsId)
{
using (MessengerDbContext context = contextFactory.Create())
{
var groupsCondition = PredicateBuilder.New <Group>();
groupsCondition = groupsId.Aggregate(groupsCondition,
(current, value) => current.Or(opt => opt.GroupId == value).Expand());
var groups = await context.Groups
.Include(opt => opt.ContactGroups)
.ThenInclude(opt => opt.Contact)
.Where(groupsCondition)
.ToListAsync()
.ConfigureAwait(false);
return(GroupConverter.GetGroupsDto(groups));
}
}
public Group CreateGroup(Group group)
{
string path = template.UrlFor(UrlTemplate.GROUPS_PATH).Build();
Silanis.ESL.API.Group apiGroup = new GroupConverter(group).ToAPIGroupWithoutMembers();
try {
string json = JsonConvert.SerializeObject(apiGroup, settings);
string response = restClient.Post(path, json);
Silanis.ESL.API.Group apiResponse = JsonConvert.DeserializeObject <Silanis.ESL.API.Group> (response);
Group sdkGroup = new GroupConverter(apiResponse).ToSDKGroup();
foreach (GroupMember groupMember in group.Members)
{
InviteMember(sdkGroup.Id, groupMember);
}
return(sdkGroup);
} catch (Exception e) {
throw new EslException("Failed to create new group." + " Exception: " + e.Message);
}
}
public virtual MessageTemplate CreateTemplateFromMessage(Message templateDef, ITemplateRegistry registry)
{
//string name = templateDef.GetString("Name");
//Field[] fields = GroupConverter.ParseFieldInstructions(templateDef, registry, _initialContext);
//return new MessageTemplate(name, fields);
string name = templateDef.GetString("Name");
string tempnamespace = "";
IFieldValue retNs;
if (templateDef.TryGetValue("Ns", out retNs) && retNs != null)
{
tempnamespace = retNs.ToString();
}
Field[] fields = GroupConverter.ParseFieldInstructions(templateDef, registry, _initialContext);
var group = new MessageTemplate(new QName(name, tempnamespace), fields);
IFieldValue retTypeRef;
if (templateDef.TryGetValue("TypeRef", out retTypeRef) && retTypeRef != null)
{
var typeRef = (GroupValue)retTypeRef;
string typeRefName = typeRef.GetString("Name");
string typeRefNs = ""; // context.getNamespace();
IFieldValue retNs2;
if (typeRef.TryGetValue("Ns", out retNs2) && retNs2 != null)
{
typeRefNs = retNs2.ToString();
}
group.TypeReference = new QName(typeRefName, typeRefNs);
}
IFieldValue retAuxId;
if (templateDef.TryGetValue("AuxId", out retAuxId) && retAuxId != null)
{
group.Id = retAuxId.ToString();
}
return(group);
}
public GroupService(MySQLContext mySQLContext)
{
_mySQLContext = mySQLContext;
_converter = new GroupConverter();
}
public GroupConverterShould()
{
_converter = new GroupConverter();
}
public Group GetGroup( GroupId groupId ) {
Silanis.ESL.API.Group apiGroup = apiClient.GetGroup(groupId.Id);
Group sdkGroup = new GroupConverter( apiGroup ).ToSDKGroup();
return sdkGroup;
}
public GroupService(IUnitOfWork uow)
{
_uow = uow;
_converter = new GroupConverter();
_studentConverter = new StudentConverter();
}
public Group UpdateGroup( Group group, GroupId groupId ) {
Silanis.ESL.API.Group apiGroup = new GroupConverter( group ).ToAPIGroup();
apiGroup = apiClient.UpdateGroup( apiGroup, groupId.Id );
Group sdkGroup = new GroupConverter( apiGroup ).ToSDKGroup();
return sdkGroup;
}
