private List <TrusteeDateOfBirth> MapTrusteesDataToViewModel(TabularData trusteeData)
        {
            var trusteeDatesOfBirth = new List <TrusteeDateOfBirth>();

            if (trusteeData != null && trusteeData.DataRows != null)
            {
                foreach (var trustee in trusteeData.DataRows)
                {
                    var trusteeDob = new TrusteeDateOfBirth
                    {
                        Id   = trustee.Id,
                        Name = trustee.Columns[0]
                    };
                    if (trustee.Columns.Count > 1)
                    {
                        var shortDob = trustee.Columns[1];
                        trusteeDob.DobMonth = DateOfBirthFormatter.GetMonthNumberFromShortDateOfBirth(shortDob);
                        trusteeDob.DobYear  = DateOfBirthFormatter.GetYearFromShortDateOfBirth(shortDob);
                    }
                    trusteeDatesOfBirth.Add(trusteeDob);
                }
            }

            return(trusteeDatesOfBirth);
        }
Ejemplo n.º 2
0
        private TabularData MapAnswersToTrusteesDob(TabularData trusteesData, List <Answer> answers)
        {
            if (trusteesData == null)
            {
                return(null);
            }

            if (trusteesData.HeadingTitles.Count < 2)
            {
                trusteesData.HeadingTitles.Add("Date of birth");
            }

            foreach (var trustee in trusteesData.DataRows)
            {
                var dobMonthKey = $"{trustee.Id}_Month";
                var dobYearKey  = $"{trustee.Id}_Year";
                var dobMonth    = answers.FirstOrDefault(x => x.QuestionId == dobMonthKey);
                var dobYear     = answers.FirstOrDefault(x => x.QuestionId == dobYearKey);
                if (dobMonth == null || dobYear == null)
                {
                    break;
                }
                if (trustee.Columns.Count < 2)
                {
                    trustee.Columns.Add(DateOfBirthFormatter.FormatDateOfBirth(dobMonth.Value, dobYear.Value));
                }
                else
                {
                    trustee.Columns[1] = DateOfBirthFormatter.FormatDateOfBirth(dobMonth.Value, dobYear.Value);
                }
            }

            return(trusteesData);
        }
Ejemplo n.º 3
0
        public bool IsRowAlreadyPresent(TabularData currentTabularData, TabularDataRow newRow)
        {
            var isPresent = false;

            foreach (var row in currentTabularData.DataRows)
            {
                isPresent = true;
                if (row.Columns.Count != newRow.Columns.Count)
                {
                    isPresent = false;
                }
                else
                {
                    for (var i = 0; i < row.Columns.Count; i++)
                    {
                        if (newRow.Columns[i] == row.Columns[i])
                        {
                            continue;
                        }
                        isPresent = false;
                        break;
                    }

                    if (isPresent)
                    {
                        return(isPresent);
                    }
                }
            }

            return(isPresent);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Process the new data.
        /// </summary>
        private void ProcessData()
        {
            // Get the average velocity and direction
            CalcAvgVelDir();

            // Get the boat speed
            AverageBoatSpeed();

            // Pass the data to tabular
            TabularData.ProcessData(_ensemble);
            if (TabularDataExpanded != null)
            {
                TabularDataExpanded.ProcessData(_ensemble);
            }

            TimeSeriesPlot.AddEnsemble(_ensemble);

            // Plot 3D Velocity Plot
            Plot3dVelocityPlot();

            // Update the Heatmap
            HeatmapPlot.AddEnsemble(_ensemble);
            if (HeatmapPlotExapnded != null)
            {
                HeatmapPlotExapnded.AddEnsemble(_ensemble);
            }

            // Plot the amplitude data
            AmplitudePlot.AddEnsemble(_ensemble);

            // Plot the correlation data
            CorrelationPlot.AddEnsemble(_ensemble);
        }
Ejemplo n.º 5
0
        public static List <ValidationErrorDetail> ValidateTrusteeDatesOfBirth(TabularData trusteesData, List <Answer> answers)
        {
            var errorMessages = new List <ValidationErrorDetail>();

            foreach (var trustee in trusteesData.DataRows)
            {
                var dobMonthKey = $"{trustee.Id}_Month";
                var dobYearKey  = $"{trustee.Id}_Year";
                var dobMonth    = answers.FirstOrDefault(x => x.QuestionId == dobMonthKey);
                var dobYear     = answers.FirstOrDefault(x => x.QuestionId == dobYearKey);
                if (dobMonth == null && dobYear == null)
                {
                    errorMessages.Add(new ValidationErrorDetail
                    {
                        ErrorMessage = DateOfBirthAnswerValidator.MissingDateOfBirthErrorMessage,
                        Field        = dobMonthKey
                    });
                    return(errorMessages);
                }

                var prefix            = trustee.Id + "_";
                var validatorMessages = DateOfBirthAnswerValidator.ValidateDateOfBirth(dobMonth.Value, dobYear.Value, prefix);
                if (validatorMessages.Any())
                {
                    errorMessages.AddRange(validatorMessages);
                }
            }

            return(errorMessages);
        }
        public void GetAnswers_when_TabularData_null_Returns_empty()
        {
            _tabularData = null;

            var result = TabularDataMapper.GetAnswers(_applicationId, _sequenceNumber, _sectionNumber, _pageId, _question, _tabularData);

            CollectionAssert.IsEmpty(result);
        }
Ejemplo n.º 7
0
        bool IDataParser.TryParse(FileInfo info, out TabularData tabularData)
        {
            tabularData = new TabularData().Default(info);
            IParser parser = _Factory.Create(info);

            parser.Parse(tabularData);
            return(tabularData.IsOkay);
        }
        public void GetAnswers_when_TabularData_empty_Returns_empty()
        {
            _tabularData = new TabularData();

            var result = TabularDataMapper.GetAnswers(_applicationId, _pageId, _question, _tabularData);

            CollectionAssert.IsEmpty(result);
        }
Ejemplo n.º 9
0
        bool IDataParser.TryParse(string body, out TabularData tabularData)
        {
            tabularData = new TabularData().Default(body);
            IParser parser = _Factory.Create(body);

            parser.Parse(tabularData);
            return(tabularData.IsOkay);
        }
Ejemplo n.º 10
0
        //public override void RemoveConnectionByGroup(RemoveConntectionByGroupArgs e)
        //{
        //    if (m_connCache.ContainsKey(e.GroupId))
        //    {
        //        if (!AllowClose())
        //        {
        //            e.Canceled = true;
        //            return;
        //        }
        //        Async.SafeClose(m_connCache[e.GroupId]);
        //        m_connCache.Remove(e.GroupId);
        //    }
        //}

        public override bool AllowCloseConnection(string connkey)
        {
            if (TabularData != null && TabularData.GetConnectionKey() == connkey)
            {
                return(AllowClose());
            }
            return(true);
        }
        public async Task get_list_of_whos_in_control_submitted_when_AddPeopleInControl_tag_filled(string name1, string dateOfBirth1, string name2, string dateOfBirth2)
        {
            var expectedPersonInControl2 = new PersonInControl {
                Name = name1, MonthYearOfBirth = dateOfBirth1
            };
            var expectedPersonInControl1 = new PersonInControl {
                Name = name2, MonthYearOfBirth = dateOfBirth2
            };

            var consumedTabularData = new TabularData
            {
                DataRows = new List <TabularDataRow>
                {
                    new TabularDataRow {
                        Columns = new List <string> {
                            name1, dateOfBirth1
                        }
                    },
                    new TabularDataRow {
                        Columns = new List <string> {
                            name2, dateOfBirth2
                        }
                    }
                }
            };

            _qnaApiClient
            .Setup(x => x.GetTabularDataByTag(_applicationId, RoatpWorkflowQuestionTags.AddPeopleInControl))
            .ReturnsAsync(consumedTabularData);

            _qnaApiClient
            .Setup(x => x.GetTabularDataByTag(_applicationId, RoatpWorkflowQuestionTags.AddPartners))
            .ReturnsAsync((TabularData)null);

            _qnaApiClient
            .Setup(x => x.GetAnswerByTag(_applicationId, RoatpWorkflowQuestionTags.SoleTradeDob, null))
            .ReturnsAsync((Answer)null);

            _qnaApiClient
            .Setup(x => x.GetAnswerByTag(_applicationId, RoatpWorkflowQuestionTags.UkrlpLegalName, null))
            .ReturnsAsync((Answer)null);

            var result = await _controller.GetWhosInControlFromSubmitted(_applicationId) as OkObjectResult;

            result.Value.Should().BeOfType <List <PersonInControl> >();
            var peopleInControl = (List <PersonInControl>)result.Value;

            Assert.AreEqual(2, peopleInControl.Count);
            Assert.AreEqual(peopleInControl[0].Name, expectedPersonInControl1.Name);
            Assert.AreEqual(peopleInControl[0].MonthYearOfBirth, expectedPersonInControl1.MonthYearOfBirth);
            Assert.AreEqual(peopleInControl[1].Name, expectedPersonInControl2.Name);
            Assert.AreEqual(peopleInControl[1].MonthYearOfBirth, expectedPersonInControl2.MonthYearOfBirth);

            _qnaApiClient.Verify(x => x.GetTabularDataByTag(_applicationId, RoatpWorkflowQuestionTags.AddPeopleInControl), Times.Once);
            _qnaApiClient.Verify(x => x.GetTabularDataByTag(It.IsAny <Guid>(), RoatpWorkflowQuestionTags.AddPartners), Times.Never);
            _qnaApiClient.Verify(x => x.GetAnswerByTag(It.IsAny <Guid>(), RoatpWorkflowQuestionTags.SoleTradeDob, null), Times.Never);
            _qnaApiClient.Verify(x => x.GetAnswerByTag(It.IsAny <Guid>(), RoatpWorkflowQuestionTags.UkrlpLegalName, null), Times.Never);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Shutdown the view model.
        /// </summary>
        public void Dispose()
        {
            TabularData.Dispose();

            if (TabularDataExpanded != null)
            {
                TabularDataExpanded.Dispose();
            }
        }
        public async Task <IActionResult> AddPeopleInControlDetails(AddEditPeopleInControlViewModel model)
        {
            var errorMessages = PeopleInControlValidator.Validate(model);

            if (errorMessages.Any())
            {
                model.ErrorMessages = errorMessages;
                return(View("~/Views/Roatp/WhosInControl/AddPeopleInControl.cshtml", model));
            }

            var whosInControlSection = await _qnaApiClient.GetSectionBySectionNo(model.ApplicationId, RoatpWorkflowSequenceIds.YourOrganisation, RoatpWorkflowSectionIds.YourOrganisation.WhosInControl);

            var personInControlData = await _tabularDataRepository.GetTabularDataAnswer(model.ApplicationId, RoatpWorkflowQuestionTags.AddPeopleInControl);

            var personInControl = new TabularDataRow
            {
                Id      = Guid.NewGuid().ToString(),
                Columns = new List <string>
                {
                    model.PersonInControlName,
                    DateOfBirthFormatter.FormatDateOfBirth(model.PersonInControlDobMonth, model.PersonInControlDobYear)
                }
            };

            if (personInControlData == null)
            {
                personInControlData = new TabularData
                {
                    HeadingTitles = new List <string> {
                        "Name", "Date of birth"
                    },
                    DataRows = new List <TabularDataRow>
                    {
                        personInControl
                    }
                };

                var result = await _tabularDataRepository.SaveTabularDataAnswer(
                    model.ApplicationId,
                    whosInControlSection.Id,
                    RoatpWorkflowPageIds.WhosInControl.AddPeopleInControl,
                    RoatpYourOrganisationQuestionIdConstants.AddPeopleInControl,
                    personInControlData);
            }
            else
            {
                var result = await _tabularDataRepository.UpsertTabularDataRecord(
                    model.ApplicationId,
                    whosInControlSection.Id,
                    RoatpWorkflowPageIds.WhosInControl.AddPeopleInControl,
                    RoatpYourOrganisationQuestionIdConstants.AddPeopleInControl,
                    RoatpWorkflowQuestionTags.AddPeopleInControl,
                    personInControl);
            }

            return(RedirectToAction("ConfirmPeopleInControl", new { model.ApplicationId }));
        }
Ejemplo n.º 14
0
        void NonExistentTestDataFileThrowsException(string inputPath)
        {
            // Arrange
            TabularData td = new TabularData();

            // Act
            // Assert
            Assert.ThrowsAsync <FileNotFoundException>(async() => { var results = td.LoadDataToSort(inputPath).Result; });
        }
Ejemplo n.º 15
0
        void CanLoadTestData(string inputPath)
        {
            // Arrange
            TabularData td = new TabularData();
            // Act
            var results = td.LoadDataToSort(inputPath);

            // Assert
            Assert.NotNull(results);
        }
Ejemplo n.º 16
0
        public void Checking_Row_Already_Present_When_Table_And_Row_Empty_Returns_False()
        {
            var tabularData = new TabularData {
                DataRows = new List <TabularDataRow>()
            };
            var tabularDataRow = new TabularDataRow();

            var result = new TabularDataService().IsRowAlreadyPresent(tabularData, tabularDataRow);

            Assert.IsFalse(result);
        }
Ejemplo n.º 17
0
        public async Task <QueryResult <GroupDto> > GetUserGroupsAsync(int userId, TabularData tabularData, Func <Sorting, string> sort = null)
        {
            var orderField = string.Empty;

            if (sort != null && tabularData.Sorting != null)
            {
                orderField = sort(tabularData.Sorting);
            }

            if (!string.IsNullOrWhiteSpace(tabularData.Search))
            {
                tabularData.Search = UsersHelper.ReplaceWildcardCharacters(tabularData.Search);
            }

            var parameters = new DynamicParameters();

            parameters.Add("@UserId", userId);
            parameters.Add("@Offset", tabularData.Pagination.Offset);
            parameters.Add("@Limit", tabularData.Pagination.Limit);
            parameters.Add("@OrderField", orderField);
            parameters.Add("@Search", tabularData.Search);
            parameters.Add("@Total", dbType: DbType.Int32, direction: ParameterDirection.Output);
            parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
            var userGroups = await _connectionWrapper.QueryAsync <Group>("GetUsersGroups", parameters, commandType : CommandType.StoredProcedure);

            var total     = parameters.Get <int?>("Total");
            var errorCode = parameters.Get <int?>("ErrorCode");

            if (errorCode.HasValue)
            {
                switch (errorCode.Value)
                {
                case (int)SqlErrorCodes.GeneralSqlError:
                    throw new BadRequestException(ErrorMessages.GeneralErrorOfGettingUserGroups);

                case (int)SqlErrorCodes.UserLoginNotExist:
                    throw new ResourceNotFoundException(ErrorMessages.UserNotExist, ErrorCodes.ResourceNotFound);
                }
            }

            if (!total.HasValue)
            {
                throw new BadRequestException(ErrorMessages.TotalNull);
            }

            var mappedGroups = GroupMapper.Map(userGroups);

            var queryDataResult = new QueryResult <GroupDto>()
            {
                Items = mappedGroups, Total = total.Value
            };

            return(queryDataResult);
        }
Ejemplo n.º 18
0
        protected virtual bool SetupDataTable(TabularData tabularData, List <string> lines)
        {
            bool     b        = false;
            Profiler profiler = new Profiler();

            if (profiler.TryDiscover(lines, out DataTable dt))
            {
                tabularData.Data = dt;
                b = true;
            }
            return(b);
        }
Ejemplo n.º 19
0
        public void Checking_No_FallOver_If_TabularData_Empty()
        {
            var tabularData = new TabularData {
                DataRows = new List <TabularDataRow>()
            };

            var tabularDataActual = new TabularDataService().DeduplicateData(tabularData);

            var isEqual = CompareTwoSources(tabularData, tabularDataActual);

            Assert.IsTrue(isEqual);
        }
        public async Task EditManagementHierarchy_Get_ReturnsConfirmManagementHierarchy()
        {
            var         index           = 0;
            TabularData personTableData = null;

            _tabularDataRepository.Setup(x => x.GetTabularDataAnswer(It.IsAny <Guid>(), RoatpWorkflowQuestionTags.AddManagementHierarchy)).ReturnsAsync(personTableData);
            var result = await _controller.EditManagementHierarchy(_applicationId, index);

            var viewResult = result as RedirectToActionResult;

            viewResult.Should().NotBeNull();
            viewResult.ActionName.Should().Be("ConfirmManagementHierarchy");
        }
Ejemplo n.º 21
0
        public override void Parse(TabularData tabularData)
        {
            List <string> lines = new List <string>();

            if (tabularData.Info != null)
            {
                lines = tabularData.Info.AllLines();
            }
            else if (!string.IsNullOrWhiteSpace(tabularData.Body))
            {
                lines = new List <string>(tabularData.Body.AllLines());
            }
        }
Ejemplo n.º 22
0
        public async Task <IHttpActionResult> GetGroupMembers(int groupId, [FromUri] Pagination pagination, [FromUri] Sorting sorting)
        {
            pagination.Validate();

            await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.ViewGroups);

            var tabularData = new TabularData {
                Pagination = pagination, Sorting = sorting
            };
            var result = await _groupRepository.GetGroupMembersAsync(groupId, tabularData, SortingHelper.SortUsergroups);

            return(Ok(result));
        }
Ejemplo n.º 23
0
        void CanLoadAndSaveTestData(string inputPath, string outputPath)
        {
            // Arrange
            TabularData td = new TabularData();
            // Act
            var results = td.LoadDataToSort(inputPath);

            td.SaveOrderedData(outputPath, results.Result);
            // Assert
            bool fileCreated = File.Exists(outputPath);

            Assert.True(fileCreated);
        }
Ejemplo n.º 24
0
        public TabularData DeduplicateData(TabularData tabularData)
        {
            var tabularDataDeduplicated = new TabularData {
                DataRows = new List <TabularDataRow>()
            };

            foreach (var row in tabularData.DataRows.Where(row => !IsRowAlreadyPresent(tabularDataDeduplicated, row)))
            {
                tabularDataDeduplicated.DataRows.Add(row);
            }

            tabularData.DataRows = tabularDataDeduplicated.DataRows;
            return(tabularData);
        }
Ejemplo n.º 25
0
        public async Task <IHttpActionResult> GetGroupsAndUsers([FromUri] Pagination pagination, [FromUri] Sorting sorting, string search = null, int groupId = 0)
        {
            pagination.Validate();
            SearchFieldValidator.Validate(search);

            await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.ViewGroups);

            var tabularData = new TabularData {
                Pagination = pagination, Sorting = sorting, Search = search
            };
            var result = await _groupRepository.GetGroupUsersAsync(groupId, tabularData, SortingHelper.SortUsergroups);

            return(Ok(result));
        }
Ejemplo n.º 26
0
        public async Task GetProjectGroupsAsync_GroupsFound_NoErrors()
        {
            // Arrange
            var cxn        = new SqlConnectionWrapperMock();
            var repository = new SqlGroupRepository(cxn.Object);
            var projectId  = 100;
            int errorCode  = 0;

            Group[] projectGroups =
            {
                new Group()
                {
                    Name = "Group1"
                },
                new Group()
                {
                    Name = "Group2"
                },
                new Group()
                {
                    Name = "Group3"
                }
            };

            var tabularData = new TabularData
            {
                Pagination = new Pagination {
                    Limit = 10, Offset = 0
                },
                Sorting = new Sorting {
                    Order = SortOrder.Asc, Sort = "name"
                }
            };

            cxn.SetupQueryAsync("GetAvailableGroupsForProject",
                                new Dictionary <string, object> {
                { "projectId", projectId }
            },
                                projectGroups,
                                new Dictionary <string, object> {
                { "ErrorCode", errorCode }
            });

            // Act
            await repository.GetProjectGroupsAsync(projectId, tabularData, SortingHelper.SortProjectGroups);

            // Assert
            cxn.Verify();
        }
Ejemplo n.º 27
0
        public void Checking_Row_Already_Present_When_Table_Empty_And_Row_Filled_Returns_False()
        {
            var tabularData = new TabularData {
                DataRows = new List <TabularDataRow>()
            };
            var tabularDataRow = new TabularDataRow {
                Columns = new List <string> {
                    "item 1", "item 2"
                }
            };

            var result = new TabularDataService().IsRowAlreadyPresent(tabularData, tabularDataRow);

            Assert.IsFalse(result);
        }
Ejemplo n.º 28
0
        public static TabularData Transform(TabularData tabularData)
        {
            var managementHierarchy = new TabularData
            {
                Caption       = null,
                HeadingTitles = new List <string>(TransformHeadingTitles),
                DataRows      = new List <TabularDataRow>()
            };

            if (tabularData?.DataRows != null && tabularData.DataRows.Any())
            {
                managementHierarchy.DataRows = new List <TabularDataRow>(tabularData.DataRows.Select(dr => { return(dr.TransformDataRow()); }));
            }

            return(managementHierarchy);
        }
Ejemplo n.º 29
0
        public async Task <IHttpActionResult> GetProjectRoleAssignments(int projectId, [FromUri] Pagination pagination, [FromUri] Sorting sorting, string search = null)
        {
            pagination.Validate();
            SearchFieldValidator.Validate(search);

            await
            _privilegesManager.DemandAny(Session.UserId, projectId, InstanceAdminPrivileges.AccessAllProjectsAdmin,
                                         ProjectAdminPrivileges.ViewGroupsAndRoles);

            var tabularData = new TabularData {
                Pagination = pagination, Sorting = sorting, Search = search
            };
            var result = await _instanceRepository.GetProjectRoleAssignmentsAsync(projectId, tabularData, SortingHelper.SortProjectRolesAssignments);

            return(Ok(result));
        }
Ejemplo n.º 30
0
        public void Checking_Expected_Change_If_TabularData_Has_Duplicates()
        {
            var tabularDataEntered = new TabularData
            {
                DataRows = new List <TabularDataRow> {
                    new TabularDataRow {
                        Columns = new List <string> {
                            "item 1", "item 2"
                        }
                    },
                    new TabularDataRow {
                        Columns = new List <string> {
                            "item 1", "item 2"
                        }
                    },
                    new TabularDataRow {
                        Columns = new List <string> {
                            "item 5", "item 6"
                        }
                    }
                }
            };


            var tabularDataExpected = new TabularData
            {
                DataRows = new List <TabularDataRow> {
                    new TabularDataRow {
                        Columns = new List <string> {
                            "item 1", "item 2"
                        }
                    },
                    new TabularDataRow {
                        Columns = new List <string> {
                            "item 5", "item 6"
                        }
                    }
                }
            };

            var tabularDataActual = new TabularDataService().DeduplicateData(tabularDataEntered);

            var isEqual = CompareTwoSources(tabularDataExpected, tabularDataActual);

            Assert.IsTrue(isEqual);
        }