Sign upLogin

SDPCoachMe/SDP-2023

View on GitHub
Star

Showing 48 of 55 total issues

File CachingStore.kt has 523 lines of code (exceeds 250 allowed). Consider refactoring.
Open

package com.github.sdpcoachme.database

import android.content.Context
import android.net.ConnectivityManager
import android.net.NetworkCapabilities
Severity: Major
Found in app/src/main/java/com/github/sdpcoachme/database/CachingStore.kt - About 1 day to fix

    Method getSchedule has a Cognitive Complexity of 65 (exceeds 20 allowed). Consider refactoring.
    Open

        /**
     * Gets the schedule for the current user
     *
     * @param currentWeekMonday the monday of the current week
     * @return a completable future that completes when the schedule has been retrieved (containing the newly cached schedule)
    Severity: Minor
    Found in app/src/main/java/com/github/sdpcoachme/database/CachingStore.kt - About 7 hrs 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

    Method EditTextLayout has a Cognitive Complexity of 57 (exceeds 20 allowed). Consider refactoring.
    Open

    /**
 * The layout for the EditTextActivity.
 *
 * @param initialValue The initial value of the text field.
 * @param onCancel The callback to be called when the user cancels the operation.
    Severity: Minor
    Found in app/src/main/java/com/github/sdpcoachme/profile/EditTextActivity.kt - About 6 hrs 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

    Class CachingStore has 41 methods (exceeds 20 allowed). Consider refactoring.
    Open

    /**
 * A caching database that wraps another database
 */
class CachingStore(private val wrappedDatabase: Database,
                   private val dataStore: DataStore<Preferences>,
    Severity: Minor
    Found in app/src/main/java/com/github/sdpcoachme/database/CachingStore.kt - About 5 hrs to fix

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

              /**
         * Creates a handler that can be used to launch this activity. This method should be called
         * from the onCreate method of the caller activity. The returned handler can be called from
         * anywhere in the caller activity, and takes an Intent as a parameter. The Intent should be
         * created using the getIntent method of this class.
      Severity: Major
      Found in app/src/main/java/com/github/sdpcoachme/profile/EditTextActivity.kt and 1 other location - About 4 hrs to fix
      app/src/main/java/com/github/sdpcoachme/rating/RatingActivity.kt on lines 54..85

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 325.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

              fun getHandler(caller: ActivityResultCaller): (Intent) -> CompletableFuture<Int> {
            // Keep a reference to the future so we can complete it later
            lateinit var futureValue: CompletableFuture<Int>
            // Set up lambda that handles result
            val launcher = caller.registerForActivityResult(
      Severity: Major
      Found in app/src/main/java/com/github/sdpcoachme/rating/RatingActivity.kt and 1 other location - About 4 hrs to fix
      app/src/main/java/com/github/sdpcoachme/profile/EditTextActivity.kt on lines 102..142

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 325.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Class FireDatabase has 33 methods (exceeds 20 allowed). Consider refactoring.
      Open

      /**
 * A database class that uses Firebase
 */
class FireDatabase(databaseReference: DatabaseReference) : Database {
      Severity: Minor
      Found in app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt - About 4 hrs to fix

        Method RatingView has a Cognitive Complexity of 40 (exceeds 20 allowed). Consider refactoring.
        Open

        @Composable
fun RatingView(
    title: String,
    initialRating: Int,
    onCancel: () -> Unit,
        Severity: Minor
        Found in app/src/main/java/com/github/sdpcoachme/rating/RatingView.kt - About 3 hrs 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

        Method RatingView has 61 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        @Composable
fun RatingView(
    title: String,
    initialRating: Int,
    onCancel: () -> Unit,
        Severity: Major
        Found in app/src/main/java/com/github/sdpcoachme/rating/RatingView.kt - About 2 hrs to fix

          Method EditTextLayout has 54 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          /**
 * The layout for the EditTextActivity.
 *
 * @param initialValue The initial value of the text field.
 * @param onCancel The callback to be called when the user cancels the operation.
          Severity: Major
          Found in app/src/main/java/com/github/sdpcoachme/profile/EditTextActivity.kt - About 2 hrs to fix

            Method getSchedule has 46 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                /**
     * Gets the schedule for the current user
     *
     * @param currentWeekMonday the monday of the current week
     * @return a completable future that completes when the schedule has been retrieved (containing the newly cached schedule)
            Severity: Minor
            Found in app/src/main/java/com/github/sdpcoachme/database/CachingStore.kt - About 1 hr to fix

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                  override fun getAllGroupEvents(): CompletableFuture<List<GroupEvent>> {
        return getRef(groupEvents)
            .thenApply { getAllChildren(it) }
            .thenApply { events -> mapDStoList(events.values, GroupEvent::class.java) }
    }
              Severity: Major
              Found in app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt and 1 other location - About 1 hr to fix
              app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt on lines 247..252

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 138.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                  override fun getAllUsers(): CompletableFuture<List<UserInfo>> {
        return getRef(accounts)
            .thenApply { getAllChildren(it) }
            .thenApply { users -> mapDStoList(users.values, UserInfo::class.java)
        }
              Severity: Major
              Found in app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt and 1 other location - About 1 hr to fix
              app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt on lines 53..57

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 138.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                  /**
     * Gets a key-value pair with a given key in a given database reference
     * @param databaseChild the database reference in which to get the key-value pair
     * @param key the key of the value
     * @return a completable future that completes when the child is set. If the key does not exist,
              Severity: Major
              Found in app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt and 1 other location - About 1 hr to fix
              app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt on lines 306..319

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 124.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                  /**
     * Checks if a child with a given key exists in a given database reference
     * @param databaseChild the database reference in which to check for the existence of the child
     * @param key the key of the child
     * @return a completable future that completes with true if the child exists, false otherwise
              Severity: Major
              Found in app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt and 1 other location - About 1 hr to fix
              app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt on lines 290..304

              Duplicated Code

              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

              Tuning

              This issue has a mass of 124.

              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

              Refactorings

              Further Reading

              Method sendMessagingNotification has 33 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  /**
     * Create and show a notification containing the received FCM message for in-app push notifications.
     * Depending on the current state of the application, the notification will open the chat activity,
     * the coaches list activity or the login activity (based on current user's email and the sender argument).
     *
              Severity: Minor
              Found in app/src/main/java/com/github/sdpcoachme/messaging/InAppNotifier.kt - About 1 hr to fix

                Function sendPushNotification has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  .onWrite(async (change, context) => {
    functions.logger.log("sendPushNotification function started");
    const chatId = context.params.chatId;
    const message = change.after.val();
    const sender = message.sender;
                Severity: Minor
                Found in functions/src/index.ts - About 1 hr to fix

                  Method getContactRowInfos has a Cognitive Complexity of 26 (exceeds 20 allowed). Consider refactoring.
                  Open

                      override fun getContactRowInfos(email: String): CompletableFuture<List<ContactRowInfo>> {
        return getUser(email).thenApply {
            // this line has been added to prevent strange buts where the chatContacts list
            // contains null values (which should not be possible according to AndroidStudio but can happen)
            it.chatContacts.filterNotNull()
                  Severity: Minor
                  Found in app/src/main/java/com/github/sdpcoachme/database/FireDatabase.kt - 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

                  Similar blocks of code found in 7 locations. Consider refactoring.
                  Open

                          class RatingCancelledException(message: String? = null, cause: Throwable? = null) : Exception(message, cause) {
            constructor(cause: Throwable) : this(null, cause)
        }
                  Severity: Major
                  Found in app/src/main/java/com/github/sdpcoachme/rating/RatingActivity.kt and 6 other locations - About 1 hr to fix
                  app/src/main/java/com/github/sdpcoachme/database/Database.kt on lines 178..181
                  app/src/main/java/com/github/sdpcoachme/location/autocomplete/AddressAutocompleteHandler.kt on lines 25..28
                  app/src/main/java/com/github/sdpcoachme/location/autocomplete/AddressAutocompleteHandler.kt on lines 29..31
                  app/src/main/java/com/github/sdpcoachme/profile/EditTextActivity.kt on lines 149..152
                  app/src/main/java/com/github/sdpcoachme/profile/EditTextActivity.kt on lines 153..155
                  app/src/main/java/com/github/sdpcoachme/rating/RatingActivity.kt on lines 91..94

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 104.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Similar blocks of code found in 7 locations. Consider refactoring.
                  Open

                          // Used to handle rating activity errors or cancelling
        class RatingFailedException(message: String? = null, cause: Throwable? = null) : Exception(message, cause) {
            constructor(cause: Throwable) : this(null, cause)
        }
                  Severity: Major
                  Found in app/src/main/java/com/github/sdpcoachme/rating/RatingActivity.kt and 6 other locations - About 1 hr to fix
                  app/src/main/java/com/github/sdpcoachme/database/Database.kt on lines 178..181
                  app/src/main/java/com/github/sdpcoachme/location/autocomplete/AddressAutocompleteHandler.kt on lines 25..28
                  app/src/main/java/com/github/sdpcoachme/location/autocomplete/AddressAutocompleteHandler.kt on lines 29..31
                  app/src/main/java/com/github/sdpcoachme/profile/EditTextActivity.kt on lines 149..152
                  app/src/main/java/com/github/sdpcoachme/profile/EditTextActivity.kt on lines 153..155
                  app/src/main/java/com/github/sdpcoachme/rating/RatingActivity.kt on lines 95..97

                  Duplicated Code

                  Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                  Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                  When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                  Tuning

                  This issue has a mass of 104.

                  We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                  The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                  If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                  See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                  Refactorings

                  Further Reading

                  Severity
                  Category
                  Status
                  Source
                  Language