Пример #1
0
        public string ExtendUserSession(int userId)
        {
            // TODO: [TESTS] (UserService.ExtendUserSession) Add tests
            var builder = new ServiceMetricBuilder(nameof(UserService), nameof(ExtendUserSession))
                          .WithCategory(MetricCategory.User, MetricSubCategory.Update)
                          .WithCustomInt1(userId);

            try
            {
                using (builder.WithTiming())
                {
                    return(GenerateJwtToken(userId));
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(null);
            }
            finally
            {
                _metrics.SubmitPoint(builder.Build());
            }
        }
Пример #2
0
        public async Task <bool> Update(int userId, ClientDto clientDto)
        {
            // TODO: [TESTS] (ClientService.Update) Add tests
            var builder = new ServiceMetricBuilder(nameof(ClientService), nameof(Update))
                          .WithCategory(MetricCategory.Client, MetricSubCategory.Update)
                          .WithCustomInt1(userId)
                          .WithCustomInt2(clientDto.ClientId);

            try
            {
                using (builder.WithTiming())
                {
                    ClientEntity dbEntry;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        dbEntry = await _clientRepo.GetById(clientDto.ClientId);

                        builder.CountResult(dbEntry);
                    }

                    if (dbEntry == null)
                    {
                        // TODO: [HANDLE] (ClientService.Update) Handle not found
                        return(false);
                    }

                    if (dbEntry.UserId != userId)
                    {
                        // TODO: [HANDLE] (ClientService.Update) Handle wrong owner
                        return(false);
                    }

                    using (builder.WithCustomTiming2())
                    {
                        builder.IncrementQueryCount();
                        if (await _clientRepo.Update(clientDto.ToDbEntity()) <= 0)
                        {
                            return(false);
                        }

                        builder.IncrementResultsCount();
                        return(true);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(false);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #3
0
        public async Task <List <IntListItem> > GetProjectsAsList(int userId, int productId)
        {
            // TODO: [TESTS] (ProjectService.GetProjectsAsList) Add tests
            var builder = new ServiceMetricBuilder(nameof(ProjectService), nameof(GetProjectsAsList))
                          .WithCategory(MetricCategory.Project, MetricSubCategory.GetList)
                          .WithCustomInt1(userId)
                          .WithCustomInt2(productId)
                          .WithCustomInt3(0);

            try
            {
                using (builder.WithTiming())
                {
                    List <ProjectEntity> dbEntries;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        dbEntries = await _projectRepo.GetAllForProduct(productId);

                        builder.WithResultsCount(dbEntries?.Count ?? 0);
                    }

                    if (dbEntries == null || dbEntries.Count <= 0)
                    {
                        // TODO: [HANDLE] (ProjectService.GetProjectsAsList) Handle this
                        return(new List <IntListItem>());
                    }

                    if (dbEntries.First().UserId != userId)
                    {
                        // TODO: [HANDLE] (ProjectService.GetProjectsAsList) Handle this
                        return(new List <IntListItem>());
                    }

                    return(dbEntries
                           .AsQueryable()
                           .Select(project => new IntListItem
                    {
                        Name = project.ProjectName,
                        Value = project.ProjectId
                    })
                           .ToList());
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(new List <IntListItem>());
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #4
0
        public async Task <ClientDto> GetById(int userId, int clientId)
        {
            // TODO: [TESTS] (ClientService.GetById) Add tests
            var builder = new ServiceMetricBuilder(nameof(ClientService), nameof(GetById))
                          .WithCategory(MetricCategory.Client, MetricSubCategory.GetById)
                          .WithCustomInt1(userId)
                          .WithCustomInt2(clientId);

            try
            {
                using (builder.WithTiming())
                {
                    ClientEntity dbClient;
                    using (builder.WithCustomTiming2())
                    {
                        builder.IncrementQueryCount();
                        dbClient = await _clientRepo.GetById(clientId);

                        builder.CountResult(dbClient);
                    }

                    if (dbClient == null)
                    {
                        return(null);
                    }

                    // ReSharper disable once InvertIf
                    if (dbClient.UserId != userId)
                    {
                        // TODO: [HANDLE] (ClientService.GetById) Handle this better
                        _logger.Warning("Requested client '{cname}' ({cid}) does not belong to user ({uid})",
                                        dbClient.ClientName,
                                        dbClient.ClientId,
                                        userId
                                        );

                        return(null);
                    }

                    return(ClientDto.FromEntity(dbClient));
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(null);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #5
0
        public async Task <ProjectDto> GetById(int userId, int projectId)
        {
            // TODO: [TESTS] (ProjectService.GetById) Add tests
            var builder = new ServiceMetricBuilder(nameof(ProjectService), nameof(GetById))
                          .WithCategory(MetricCategory.Project, MetricSubCategory.GetById)
                          .WithCustomInt1(userId)
                          .WithCustomInt2(0)
                          .WithCustomInt3(projectId);

            try
            {
                using (builder.WithTiming())
                {
                    ProjectEntity dbEntry;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        dbEntry = await _projectRepo.GetById(projectId);

                        builder.CountResult(dbEntry);
                    }

                    if (dbEntry == null)
                    {
                        // TODO: [HANDLE] (ProjectService.GetById) Handle this
                        return(null);
                    }

                    builder.WithCustomInt2(dbEntry.ProductId);
                    if (dbEntry.UserId != userId)
                    {
                        // TODO: [HANDLE] (ProjectService.GetById) Handle this
                        return(null);
                    }

                    return(ProjectDto.FromEntity(dbEntry));
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(null);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #6
0
        public async Task <AuthenticationResponse> Authenticate(AuthenticationRequest request)
        {
            // TODO: [TESTS] (UserService.Authenticate) Add tests
            var builder = new ServiceMetricBuilder(nameof(UserService), nameof(Authenticate))
                          .WithCategory(MetricCategory.User, MetricSubCategory.GetSingle)
                          .WithCustomTag1(request.Username);

            try
            {
                using (builder.WithTiming())
                {
                    UserEntity loggedInUser;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        loggedInUser = await LoginUser(request.Username, request.Password);

                        builder.CountResult(loggedInUser);
                    }

                    if (loggedInUser == null)
                    {
                        return(null);
                    }

                    builder.WithCustomInt1(loggedInUser.UserId);

                    return(new AuthenticationResponse
                    {
                        FirstName = loggedInUser.FirstName,
                        LastName = loggedInUser.LastName,
                        UserId = loggedInUser.UserId,
                        Username = loggedInUser.Username,
                        Token = GenerateJwtToken(loggedInUser.UserId)
                    });
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(null);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #7
0
        // Interface methods
        public async Task <UserDto> GetFromToken(string token)
        {
            // TODO: [TESTS] (UserService.GetFromToken) Add tests
            var builder = new ServiceMetricBuilder(nameof(UserService), nameof(GetFromToken))
                          .WithCategory(MetricCategory.User, MetricSubCategory.Extract);

            try
            {
                using (builder.WithTiming())
                {
                    // Try extract the current userId
                    int userId;
                    using (builder.WithCustomTiming1())
                    {
                        userId = ExtractUserId(token);
                        if (userId == 0)
                        {
                            return(null);
                        }
                    }

                    UserEntity userEntity;
                    using (builder.WithCustomTiming2())
                    {
                        builder.IncrementQueryCount();
                        userEntity = await _userRepo.GetUserById(userId);

                        builder.CountResult(userEntity);
                    }

                    return(userEntity == null ? null : UserDto.Projection.Compile()(userEntity));
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(null);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #8
0
        public async Task <bool> UpdateProduct(int userId, ProductDto productDto)
        {
            // TODO: [TESTS] (ProductService.UpdateProduct) Add tests
            // TODO: [VALIDATION] (ProductService.UpdateProduct) Ensure that user owns this product
            var builder = new ServiceMetricBuilder(nameof(ProductService), nameof(UpdateProduct))
                          .WithCategory(MetricCategory.Product, MetricSubCategory.Update)
                          .WithCustomInt1(userId)
                          .WithCustomInt2(productDto.ClientId);

            try
            {
                using (builder.WithTiming())
                {
                    if (productDto.UserId != userId)
                    {
                        // TODO: [HANDLE] (ProductService.UpdateProduct) Handle this better
                        return(false);
                    }

                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        if (await _productRepo.Update(productDto.AsProductEntity()) <= 0)
                        {
                            return(false);
                        }

                        builder.WithResultsCount(1);
                        return(true);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(false);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #9
0
        public async Task <List <ClientDto> > GetAll(int userId)
        {
            // TODO: [TESTS] (ClientService.GetAll) Add tests
            var builder = new ServiceMetricBuilder(nameof(ClientService), nameof(GetAll))
                          .WithCategory(MetricCategory.Client, MetricSubCategory.GetAll)
                          .WithCustomInt1(userId);

            try
            {
                using (builder.WithTiming())
                {
                    List <ClientEntity> dbClients;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        dbClients = await _clientRepo.GetAll(userId);

                        builder.WithResultsCount(dbClients?.Count ?? 0);
                    }

                    if (dbClients == null || dbClients.Count == 0)
                    {
                        return(new List <ClientDto>());
                    }

                    return(dbClients
                           .AsQueryable()
                           .Select(ClientDto.Projection)
                           .ToList());
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(new List <ClientDto>());
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #10
0
        public async Task <List <IntListItem> > GetAsListItems(int userId)
        {
            // TODO: [TESTS] (ClientService.GetAsListItems) Add tests
            var builder = new ServiceMetricBuilder(nameof(ClientService), nameof(GetAsListItems))
                          .WithCategory(MetricCategory.Client, MetricSubCategory.GetList)
                          .WithCustomInt1(userId);

            try
            {
                using (builder.WithTiming())
                {
                    List <ClientEntity> clientEntries;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        clientEntries = await _clientRepo.GetAll(userId);

                        builder.WithResultsCount(clientEntries.Count);
                    }

                    return(clientEntries
                           .AsQueryable()
                           .Select(clientEntry => new IntListItem
                    {
                        Value = clientEntry.ClientId,
                        Name = clientEntry.ClientName
                    })
                           .ToList());
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(new List <IntListItem>());
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #11
0
        // Interface methods
        public async Task <RawOptions> GenerateOptions(string category, int userId)
        {
            // TODO: [TESTS] (OptionsService.GetRawOptionsForCategory) Add tests
            var builder = new ServiceMetricBuilder(nameof(OptionsService), nameof(GenerateOptions))
                          .WithCategory(MetricCategory.Option, MetricSubCategory.Generate)
                          .WithCustomInt1(userId)
                          .WithCustomTag1(category);

            var generated = new RawOptions(category);

            try
            {
                using (builder.WithTiming())
                {
                    List <OptionEntity> dbOptions;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        dbOptions = await _optionRepo.GetRawOptionsForCategory(category, userId);

                        builder.WithResultsCount(dbOptions.Count);
                    }

                    foreach (var dbOption in dbOptions)
                    {
                        generated.AddOption(dbOption);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }

            return(generated);
        }
Пример #12
0
        public async Task <bool> AddProject(int userId, ProjectDto projectDto)
        {
            // TODO: [TESTS] (ProjectService.AddProject) Add tests
            // TODO: [VALIDATION] (ProjectService.AddProject) Add validation
            var builder = new ServiceMetricBuilder(nameof(ProjectService), nameof(AddProject))
                          .WithCategory(MetricCategory.Project, MetricSubCategory.Add)
                          .WithCustomInt1(userId)
                          .WithCustomInt2(projectDto.ProductId)
                          .WithCustomInt3(0);

            try
            {
                using (builder.WithTiming())
                {
                    var projectEntity = projectDto.AsProjectEntity();
                    projectEntity.UserId = userId;

                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        if (await _projectRepo.Add(projectEntity) <= 0)
                        {
                            return(false);
                        }

                        builder.WithResultsCount(1);
                        return(true);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(false);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #13
0
        public async Task <List <ProjectDto> > GetAllForProduct(int userId, int productId)
        {
            // TODO: [TESTS] (ProjectService.GetAllForProduct) Add tests
            // TODO: [VALIDATION] (ProjectService.GetAllForProduct) Ensure that the current user can see these
            var builder = new ServiceMetricBuilder(nameof(ProjectService), nameof(GetAllForProduct))
                          .WithCategory(MetricCategory.Project, MetricSubCategory.GetAll)
                          .WithCustomInt1(userId)
                          .WithCustomInt2(productId)
                          .WithCustomInt3(0);

            try
            {
                using (builder.WithTiming())
                {
                    List <ProjectEntity> dbEntries;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        dbEntries = await _projectRepo.GetAllForProduct(productId);

                        builder.WithResultsCount(dbEntries.Count);
                    }

                    return(dbEntries
                           .AsQueryable()
                           .Select(ProjectDto.Projection)
                           .ToList());
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(new List <ProjectDto>());
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #14
0
        public async Task <bool> AddClient(int userId, ClientDto clientDto)
        {
            // TODO: [TESTS] (ClientService.AddClient) Add tests
            var builder = new ServiceMetricBuilder(nameof(ClientService), nameof(AddClient))
                          .WithCategory(MetricCategory.Client, MetricSubCategory.Add)
                          .WithCustomInt1(userId);

            try
            {
                using (builder.WithTiming())
                {
                    var clientEntity = clientDto.ToDbEntity();
                    clientEntity.UserId = userId;

                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        if (await _clientRepo.Add(clientEntity) <= 0)
                        {
                            return(false);
                        }

                        builder.WithResultsCount(1);
                        return(true);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(false);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }
Пример #15
0
        public async Task <bool> UpdateProject(int userId, ProjectDto projectDto)
        {
            // TODO: [TESTS] (ProjectService.UpdateProject) Add tests
            // TODO: [VALIDATE] (ProjectService.UpdateProject) Ensure that the user can edit this
            var builder = new ServiceMetricBuilder(nameof(ProjectService), nameof(UpdateProject))
                          .WithCategory(MetricCategory.Project, MetricSubCategory.Update)
                          .WithCustomInt1(userId)
                          .WithCustomInt2(projectDto.ProductId)
                          .WithCustomInt3(projectDto.ProjectId);

            try
            {
                using (builder.WithTiming())
                {
                    ProjectEntity dbEntry;
                    using (builder.WithCustomTiming1())
                    {
                        builder.IncrementQueryCount();
                        dbEntry = await _projectRepo.GetById(projectDto.ProjectId);

                        builder.CountResult(dbEntry);
                    }

                    if (dbEntry == null)
                    {
                        // TODO: [HANDLE] (ProjectService.UpdateProject) Handle this
                        return(false);
                    }

                    if (dbEntry.UserId != userId)
                    {
                        // TODO: [HANDLE] (ProjectService.UpdateProject) Handle this
                        return(false);
                    }

                    var projectEntity = projectDto.AsProjectEntity();
                    projectEntity.UserId = userId;

                    using (builder.WithCustomTiming2())
                    {
                        builder.IncrementQueryCount();
                        if (await _projectRepo.Update(projectEntity) <= 0)
                        {
                            return(false);
                        }

                        builder.IncrementResultsCount();
                        return(true);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogUnexpectedException(ex);
                builder.WithException(ex);
                return(false);
            }
            finally
            {
                await _metrics.SubmitPointAsync(builder.Build());
            }
        }