/// <summary>
        ///     All references.
        /// </summary>
        /// <returns><see cref="IEnumerable{Reference}" />.</returns>
        public async Task <IEnumerable <Reference> > All()
        {
            using (var db = new PRACTISEV1DB())
            {
                var items = await db.GetTable <UtilitySchema.Reference>()
                            .GroupJoin(db.GetTable <UtilitySchema.ReferenceItem>(), reference => reference.Id, referenceItem => referenceItem.ReferenceId, (parent, child) => Build(parent, child.ToList()))
                            .ToListAsync();

                return(items);
            }
        }
        /// <summary>
        ///     All users.
        /// </summary>
        /// <returns><see cref="IEnumerable{User}" />.</returns>
        public async Task <IEnumerable <User> > All()
        {
            using (var db = new PRACTISEV1DB())
            {
                var items = await db.GetTable <AdministrationSchema.User>().Take(1000)
                            .LeftJoin(db.GetTable <AdministrationSchema.UserProfile>(),
                                      (user, userProfile) => user.Id == userProfile.UserId, (user, userProfile) => new { user, userProfile })
                            .GroupJoin(db.GetTable <AdministrationSchema.UserClaim>(), user => user.user.Id, userClaim => userClaim.UserId, (parent, claims) => Build(parent.user, parent.userProfile, claims.ToList()))
                            .ToListAsync();

                return(items);
            }
        }
        /// <summary>
        ///     Get reference.
        /// </summary>
        /// <param name="id">The Id</param>
        /// <returns><see cref="Reference" />.</returns>
        public async Task <Reference> Get(Guid id)
        {
            if (id == Guid.Empty)
            {
                throw new ArgumentException("Invalid id", nameof(id));
            }
            using (var db = new PRACTISEV1DB())
            {
                var items = await db.GetTable <UtilitySchema.Reference>().Where(x => x.Id == id)
                            .GroupJoin(db.GetTable <UtilitySchema.ReferenceItem>(), reference => reference.Id, referenceItem => referenceItem.ReferenceId, (parent, child) => Build(parent, child.ToList()))
                            .ToListAsync();

                return(items.FirstOrDefault());
            }
        }
        /// <summary>
        ///     UserAddress.
        /// </summary>
        /// <param name="id">The user address Id.</param>
        /// <returns></returns>
        public async Task <UserAddress> UserAddress(Guid id)
        {
            if (id == Guid.Empty)
            {
                throw new ArgumentException("Invalid id", nameof(id));
            }
            using (var db = new PRACTISEV1DB())
            {
                var items = await db.GetTable <AdministrationSchema.UserAddress>().Where(x => x.Id == id)
                            .LeftJoin(db.GetTable <UtilitySchema.Address>(),
                                      (userAddress, address) => userAddress.AddressId == address.Id, (userAddress, address) => Build(userAddress, address))
                            .ToListAsync();

                return(items.FirstOrDefault());
            }
        }
        /// <summary>
        ///     Handles the request.
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task <IEnumerable <User> > Handle(GetUsersQuery request, CancellationToken cancellationToken)
        {
            using (var db = new PRACTISEV1DB())
            {
                var items = await db.GetTable <AdministrationSchema.User>().Where(x => x.Id != null)
                            .LeftJoin(db.GetTable <AdministrationSchema.UserProfile>(),
                                      (user, userProfile) => user.Id == userProfile.UserId,
                                      (user, userProfile) => new { user, userProfile })
                            .GroupJoin(db.GetTable <AdministrationSchema.UserClaim>(), user => user.user.Id,
                                       userClaim => userClaim.UserId,
                                       (parent, claims) =>
                                       AdministrationManager.Build(parent.user, parent.userProfile, claims.ToList()))
                            .ToListAsync();

                return(items);
            }
        }
        /// <summary>
        ///     Get user by user name.
        /// </summary>
        /// <param name="userName">The user name.</param>
        /// <returns></returns>
        public async Task <User> Get(string userName)
        {
            if (string.IsNullOrEmpty(userName))
            {
                throw new ArgumentException("Invalid user name", nameof(userName));
            }
            using (var db = new PRACTISEV1DB())
            {
                var items = await db.GetTable <AdministrationSchema.User>().Where(x => x.UserName == userName)
                            .LeftJoin(db.GetTable <AdministrationSchema.UserProfile>(),
                                      (user, userProfile) => user.Id == userProfile.UserId, (user, userProfile) => new { user, userProfile })
                            .GroupJoin(db.GetTable <AdministrationSchema.UserClaim>(), user => user.user.Id, userClaim => userClaim.UserId, (parent, claims) => Build(parent.user, parent.userProfile, claims.ToList()))
                            .ToListAsync();

                return(items.FirstOrDefault());
            }
        }
Exemplo n.º 7
0
        /// <summary>
        ///     Handles the request.
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task <User> Handle(GetUserQuery request, CancellationToken cancellationToken)
        {
            if (request.Id == Guid.Empty)
            {
                throw new ArgumentException("Invalid id", nameof(request.Id));
            }
            using (var db = new PRACTISEV1DB())
            {
                var items = await db.GetTable <AdministrationSchema.User>().Where(x => x.Id == request.Id)
                            .LeftJoin(db.GetTable <AdministrationSchema.UserProfile>(),
                                      (user, userProfile) => user.Id == userProfile.UserId,
                                      (user, userProfile) => new { user, userProfile })
                            .GroupJoin(db.GetTable <AdministrationSchema.UserClaim>(), user => user.user.Id,
                                       userClaim => userClaim.UserId,
                                       (parent, claims) =>
                                       AdministrationManager.Build(parent.user, parent.userProfile, claims.ToList()))
                            .ToListAsync();

                await _mediator.Publish(new GetUsersNotification(items?.FirstOrDefault()?.Profile?.FirstName, items?.FirstOrDefault()?.Profile?.LastName));

                return(items.FirstOrDefault());
            }
        }