public RepositoryManager(ShuflContext context)
{
AlbumRepository = new AlbumRepository(context);
AlbumArtistRepository = new AlbumArtistRepository(context);
AlbumImageRepository = new AlbumImageRepository(context);
ArtistRepository = new ArtistRepository(context);
ArtistImageRepository = new ArtistImageRepository(context);
ArtistGenreRepository = new ArtistGenreRepository(context);
GenreRepository = new GenreRepository(context);
GroupRepository = new GroupRepository(context);
GroupAlbumRepository = new GroupAlbumRepository(context);
GroupAlbumRatingRepository = new GroupAlbumRatingRepository(context);
GroupInviteRepository = new GroupInviteRepository(context);
GroupMemberRepository = new GroupMemberRepository(context);
GroupPlaylistRepository = new GroupPlaylistRepository(context);
GroupPlaylistRatingRepository = new GroupPlaylistRatingRepository(context);
PasswordResetRepository = new PasswordResetRepository(context);
PlaylistRepository = new PlaylistRepository(context);
PlaylistImageRepository = new PlaylistImageRepository(context);
TrackRepository = new TrackRepository(context);
TrackArtistRepository = new TrackArtistRepository(context);
UserRepository = new UserRepository(context);
UserImageRepository = new UserImageRepository(context);
UserVerificationRepository = new UserVerificationRepository(context);
}
public AdduserViewModel(GroupMemberRepository groupMemberRepository, UserRepository userRepository, IMediator mediator)
{
this.groupMemberRepository = groupMemberRepository;
this.userRepository = userRepository;
this.mediator = mediator;
this.AddUserToGroupCommand = new RelayCommand(AddUserToGroupFunction);
}
public void InsertGroupMember()
{
GroupMemberRepository groupMemberRepository = new GroupMemberRepository(new InMemoryDbContextFactory().CreateDbContext());
GroupModel groupModel = new GroupModel
{
Id = Guid.NewGuid(),
Name = "První cenová skupina",
Description = "Popisek testovací skupiny První cenová skupiina",
};
UserModel userModel = new UserModel
{
Id = Guid.NewGuid(),
Name = "Martin",
Surname = "Vlach",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "+420420420420"
};
GroupMemberModel groupMemberModel = new GroupMemberModel
{
Id = Guid.NewGuid(),
Group = groupModel,
User = userModel,
Permission = PermissionEnum.Moderator
};
groupMemberRepository.Insert(groupMemberModel);
var groupMemberRepositoryResponse = groupMemberRepository.GetById(groupMemberModel.Id);
Assert.NotNull(groupMemberRepositoryResponse);
Assert.Equal(userModel.Name, groupMemberModel.User.Name);
Assert.Equal(groupModel.Name, groupMemberModel.Group.Name);
}
public ViewModelLocator()
{
mediator = new Mediator();
groupRepository = new GroupRepository(new CommunicationDbContext());
userRepository = new UserRepository(new CommunicationDbContext());
contributionRepository = new ContributionRepository(new CommunicationDbContext());
commentRepository = new CommentRepository(new CommunicationDbContext());
groupMemberRepository = new GroupMemberRepository(new CommunicationDbContext());
}
public NewGroupViewModel(GroupRepository groupRepository, GroupMemberRepository groupMemberRepository, IMediator mediator)
{
this.groupRepository = groupRepository;
this.groupMemberRepository = groupMemberRepository;
this.mediator = mediator;
SaveCommand = new RelayCommand(Save);
CancelCommand = new RelayCommand(Cancel);
mediator.Register <ShowGroupRegistration>(ShowWindow);
mediator.Register <CloseRegistrationGroupWindow>(CloseWindow);
}
public void RemoveMemberFromGroup(int memberId, int structuralGroupId)
{
using (var repository = new GroupMemberRepository(ApplicationContext.DatabaseContext.Database))
{
var groupMember = repository.Get(memberId, structuralGroupId);
if (groupMember == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
repository.Delete(groupMember);
}
}
public AddOrDeleteGroupMemeberViewModel(UserRepository userRepository, GroupRepository groupRepository, GroupMemberRepository groupMemberRepository, IMediator mediator)
{
this.userRepository = userRepository;
this.groupRepository = groupRepository;
this.groupMemberRepository = groupMemberRepository;
this.mediator = mediator;
AddUserCommand = new RelayCommand(AddUser);
DeleteUserCommand = new RelayCommand(DeleteUser);
UserSelectedCommand = new RelayCommand <UserModel>(UserSelected);
Load();
}
public LayIMDapperStorage(UserRepository userRepository,
FriendGroupRepository friendGroupRepository,
FriendRelationRepository friendRelationRepository,
BigGroupRepository bigGroupRepository,
GroupMemberRepository groupMemberRepository,
ChatRecordRepository chatRecordRepository)
{
this.userRepository = userRepository;
this.friendGroupRepository = friendGroupRepository;
this.friendRelationRepository = friendRelationRepository;
this.bigGroupRepository = bigGroupRepository;
this.groupMemberRepository = groupMemberRepository;
this.chatRecordRepository = chatRecordRepository;
}
public static GroupMember AddMemberToGroup(UmbracoDatabase db, int memberId, int structuralGroupId)
{
var groupMember = new GroupMember()
{
MemberId = memberId,
StructuralGroupId = structuralGroupId
};
using (var repository = new GroupMemberRepository(db))
{
repository.Insert(groupMember);
return(groupMember);
}
}
/// <summary> Creates a new <see cref="GitLabClient" /> instance. </summary>
/// <param name="hostUri"> The GitLab server to connect to. </param>
/// <param name="privateToken"> The private token to use when making requests to the GitLab API. </param>
public GitLabClient(Uri hostUri, string privateToken = null)
{
if (hostUri == null)
{
throw new ArgumentNullException(nameof(hostUri));
}
var baseUri = new Uri(hostUri, ApiPath);
_authenticator = new PrivateTokenAuthenticator(privateToken);
var clientFactory = new ClientFactory(baseUri, _authenticator);
var requestFactory = new RequestFactory(clientFactory);
Branches = new BranchRepository(requestFactory);
Builds = new BuildRepository(requestFactory);
BuildTriggers = new BuildTriggerRepository(requestFactory);
BuildVariables = new BuildVariableRepository(requestFactory);
Commits = new CommitRepository(requestFactory);
DeployKeys = new DeployKeyRepository(requestFactory);
Emails = new EmailRepository(requestFactory);
Files = new FileRepository(requestFactory);
GitLabLicense = new GitLabLicenseRepository(requestFactory);
GitLabSettings = new GitLabSettingsRepository(requestFactory);
Issues = new IssueRepository(requestFactory);
Keys = new KeyRepository(requestFactory);
Labels = new LabelRepository(requestFactory);
Licenses = new LicenseRepository(requestFactory);
MergeRequests = new MergeRequestRepository(requestFactory);
Milestones = new MilestoneRepository(requestFactory);
Namespaces = new NamespaceRepository(requestFactory);
ProjectSnippets = new ProjectSnippetRepository(requestFactory);
Repositories = new RepositoryRepository(requestFactory);
Runners = new RunnerRepository(requestFactory);
Session = new SessionRepository(requestFactory);
SystemHooks = new SystemHookRepository(requestFactory);
Tags = new TagRepository(requestFactory);
Users = new UserRepository(requestFactory);
Projects = new ProjectRepository(requestFactory);
ProjectMembers = new ProjectMemberRepository(requestFactory);
GroupMembers = new GroupMemberRepository(requestFactory);
}
public void GetAllUsersOfGroupByGroupId()
{
InMemoryDbContextFactory Db = new InMemoryDbContextFactory();
var dbContext = Db.CreateDbContext();
GroupMemberRepository groupMemberRepository = new GroupMemberRepository(dbContext);
UserRepository userRepository = new UserRepository(dbContext);
GroupModel groupModel1 = new GroupModel
{
Id = Guid.NewGuid(),
Name = "První skupina",
Description = "Popisek1",
};
GroupModel groupModel2 = new GroupModel
{
Id = Guid.NewGuid(),
Name = "Druhá skupina",
Description = "Popisek2",
};
GroupModel groupModel3 = new GroupModel
{
Id = Guid.NewGuid(),
Name = "Třetí skupina",
Description = "Popisek3",
};
UserModel userModel1 = new UserModel
{
Id = Guid.NewGuid(),
Name = "Karel",
Surname = "Vlach",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "+420420420420",
};
UserModel userModel2 = new UserModel
{
Id = Guid.NewGuid(),
Name = "Pavel",
Surname = "Vlach",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "+420420420420",
};
UserModel userModel3 = new UserModel
{
Id = Guid.NewGuid(),
Name = "Martin",
Surname = "Vlach",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "+420420420420",
};
userRepository.Insert(userModel1);
userRepository.Insert(userModel2);
userRepository.Insert(userModel3);
var userRepositoryResponse1 = userRepository.GetById(userModel1.Id);
var userRepositoryResponse2 = userRepository.GetById(userModel2.Id);
var userRepositoryResponse3 = userRepository.GetById(userModel3.Id);
Assert.NotNull(userRepositoryResponse1);
Assert.NotNull(userRepositoryResponse2);
Assert.NotNull(userRepositoryResponse3);
GroupMemberModel groupMemberModel1 = new GroupMemberModel
{
Id = Guid.NewGuid(),
Group = groupModel1,
User = userModel1,
Permission = PermissionEnum.User
};
GroupMemberModel groupMemberModel2 = new GroupMemberModel
{
Id = Guid.NewGuid(),
Group = groupModel1,
User = userModel2,
Permission = PermissionEnum.User
};
GroupMemberModel groupMemberModel3 = new GroupMemberModel
{
Id = Guid.NewGuid(),
Group = groupModel2,
User = userModel1,
Permission = PermissionEnum.Admin
};
dbContext.DetachAllEntities();
groupMemberRepository.Insert(groupMemberModel1);
groupMemberRepository.Insert(groupMemberModel2);
groupMemberRepository.Insert(groupMemberModel3);
var groupMemberRepositoryResponse1 = groupMemberRepository.GetById(groupMemberModel1.Id);
var groupMemberRepositoryResponse2 = groupMemberRepository.GetById(groupMemberModel2.Id);
var groupMemberRepositoryResponse3 = groupMemberRepository.GetById(groupMemberModel3.Id);
Assert.NotNull(groupMemberRepositoryResponse1);
Assert.NotNull(groupMemberRepositoryResponse2);
Assert.NotNull(groupMemberRepositoryResponse3);
var userRepositoryResponseUsers = userRepository.GetAllUsersOfGroupByGroupId(groupModel1.Id);
Assert.NotNull(userRepositoryResponseUsers);
Assert.Equal(userRepositoryResponseUsers.ElementAt(0).Id, userModel1.Id);
Assert.Equal(userRepositoryResponseUsers.ElementAt(1).Id, userModel2.Id);
Assert.Equal(userRepositoryResponseUsers.Count, 2);
}
