wongjiahau/ttap-web

View on GitHub

Showing 125 of 211 total issues

Function render has 49 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  public render() {
    const divStyle: React.CSSProperties = {
      background: this.props.isSelected ? Colors.Azure : Colors.White,
    };
    const primary = (
Severity: Minor
Found in src/ts/react/subjectView.tsx - About 1 hr to fix

    Function ParseStudentHtmlToRawSlot_v2 has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
    Open

    export default function ParseStudentHtmlToRawSlot_v2(html: string): RawSlot[] {
      const result = new Array<RawSlot>();
      const htmlDoc = new DOMParser().parseFromString(html, "text/html");
      // @ts-ignore
      const tableRows = Array.from(
    Severity: Minor
    Found in src/ts/parser/parseStudentHtmlToRawSlot_v2.ts - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function moveElementAwayFromCollision has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
    Open

    function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction, compactType, cols) {
    
      var compactH = compactType === 'horizontal';
      var compactV = compactType === 'vertical';
      var preventCollision = false; // we're already colliding
    Severity: Minor
    Found in src/ts/modified_node_modules/react-grid-layout/build/utils.js - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function render has 47 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      public render() {
        if (this.state.redirect) {
          return <Redirect push={true} to="/login" />;
        }
    
    
    Severity: Minor
    Found in src/ts/react/tutorial/tutorial.tsx - About 1 hr to fix

      Function render has 45 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        public render() {
          const menuButton = (
            <IconButton onClick={this.handleOpenDrawer}>
              <MenuIcon />
            </IconButton>
      Severity: Minor
      Found in src/ts/react/app.tsx - About 1 hr to fix

        Function LoadSlotsFromUrl has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
        Open

        export const LoadSlotsFromUrl = (
          downloadUrl: string,
          fileType: string,
          started: () => void,
          successed: (loadedSlots: IRawSlot[]) => void,
        Severity: Minor
        Found in src/ts/react/selectCourseView.tsx - About 1 hr to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function GeneralizeSlot has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
        Open

        export function GeneralizeSlot(originalSlots: RawSlot[]): RawSlot[] {
          const slots = originalSlots.map(clone) as IRawSlot[];
          const results = new Array<RawSlot>();
          results.push(slots[0]);
          let generalized: boolean;
        Severity: Minor
        Found in src/ts/permutator/generalizeSlot.ts - About 1 hr to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function render has 43 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          public render() {
            const getListItem = (text: string, icon: any, handler: any) => {
              return (
                <ListItem button={true} onClick={handler}>
                  <ListItemIcon>{icon}</ListItemIcon>
        Severity: Minor
        Found in src/ts/react/saveTimetableDialog.tsx - About 1 hr to fix

          Function plotPartition has 42 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            public plotPartition(partition: T[][], partitionHeadings: string[]): void {
              // calculate full search path count
              this.fullSearchPathCount = this.setPartitionCount(
                partition.map((x) => x.length)
              );
          Severity: Minor
          Found in src/ts/permutator/findTimetableVisualizer.ts - About 1 hr to fix

            Function GenerateErrorLabels has 42 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            function GenerateErrorLabels(diffReports: DiffReport[] | null) {
              const errorStyle: React.CSSProperties = {
                color: Colors.Red,
              };
              if (!diffReports) {
            Severity: Minor
            Found in src/ts/react/slotsTableView.tsx - About 1 hr to fix

              Function Report has 41 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              const Report = (props: {
                numberOfRemovedTimetables: number;
                numberOfRemainingTimetables: number;
              }) => {
                const style: React.CSSProperties = {
              Severity: Minor
              Found in src/ts/react/setTimeConstraintView.tsx - About 1 hr to fix

                Function GenerateStateViews has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                export function GenerateStateViews(
                  states: STCBox[],
                  handleSetTimeContraintAt: (state: STCBox) => void,
                  handleDesetTimeConstraintAt: (state: STCBox) => void
                ): ISkeleton {
                Severity: Minor
                Found in src/ts/react/timetableView/generateStateView.tsx - About 1 hr to fix

                  Function GenerateSlotViewsAndDayColumn has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  export function GenerateSlotViewsAndDayColumn(
                    slots: ISlotViewModel[],
                    selectSlotChoiceHandler: (slotUid: number, newSlotChoice: number) => void,
                    goToThisAlternativeSlotHandler: (
                      sourceSlotUid: number,
                  Severity: Minor
                  Found in src/ts/react/timetableView/generateSlotViewsAndDayColumn.tsx - About 1 hr to fix

                    Function GenerateNewState has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                      protected GenerateNewState(state: IMasterState): IMasterState {
                        if (
                          state.TimetableListState.ShowingAlternateSlotOf &&
                          this.slot.Uid !== state.TimetableListState.ShowingAlternateSlotOf.Uid
                        ) {
                    Severity: Minor
                    Found in src/ts/redux/actions/showAlternateSlot.ts - About 1 hr to fix

                      Function ParseStudentHtmlToRawSlot has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                      Open

                      export default function ParseStudentHtmlToRawSlot(html: string): RawSlot[] {
                        const result = new Array<RawSlot>();
                        const htmlDoc = new DOMParser().parseFromString(html, "text/html");
                        // @ts-ignore
                        const tableRows = htmlDoc
                      Severity: Minor
                      Found in src/ts/parser/parseStudentHtmlToRawSlot.ts - About 1 hr to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function ResponsiveReactGridLayout has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                      Open

                      var ResponsiveReactGridLayout = function (_React$Component) {
                        _inherits(ResponsiveReactGridLayout, _React$Component);
                      
                        function ResponsiveReactGridLayout() {
                          var _temp, _this, _ret;

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function ParseFgoHtmlToRawSlot_v2 has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                      Open

                      export function ParseFgoHtmlToRawSlot_v2(html: string): RawSlot[] {
                        const result = new Array<RawSlot>();
                        const htmlDoc = new DOMParser().parseFromString(html, "text/html");
                      
                        const tableRows = htmlDoc
                      Severity: Minor
                      Found in src/ts/parser/parseFgoHtmlToRawSlot_v2.ts - About 1 hr to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function ParseFgoHtmlToRawSlot_v1 has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                      Open

                      export function ParseFgoHtmlToRawSlot_v1(html: string): RawSlot[] {
                        const result = new Array<RawSlot>();
                        const htmlDoc = new DOMParser().parseFromString(html, "text/html");
                      
                        const tableRows = htmlDoc
                      Severity: Minor
                      Found in src/ts/parser/parseFgoHtmlToRawSlot.ts - About 1 hr to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function render has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                        public render() {
                          if (!this.props.slots) {
                            return false;
                          }
                          const subjectSummaries = new TimetableSummary(this.props.slots)
                      Severity: Minor
                      Found in src/ts/react/timetableSummaryView.tsx - About 1 hr to fix

                        Function WidthProvider has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        var WidthProvider = function WidthProvider(ComposedComponent) {
                          var _class, _temp2;
                        
                          return _temp2 = _class = function (_React$Component) {
                            _inherits(_class, _React$Component);
                          Severity
                          Category
                          Status
                          Source
                          Language