OpenSRP/opensrp-client-anc

View on GitHub

Showing 436 of 436 total issues

Method onCreate has 29 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    @Override
    public void onCreate() {
        super.onCreate();

        mInstance = this;

    Method addAttentionFlagsService has 29 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        protected void addAttentionFlagsService() {
            try {
                JSONObject jsonObject = new JSONObject(AncLibrary.getInstance().getDetailsRepository().getAllDetailsForClient(pc.getCaseId()).get(ConstantsUtils.DetailsKeyUtils.ATTENTION_FLAG_FACTS));
    
                Facts facts = new Facts();

      Method processRequiredStepsField has 29 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          private void processRequiredStepsField(JSONObject object) throws Exception {
              if (object != null && object.has(ConstantsUtils.JsonFormKeyUtils.ENCOUNTER_TYPE)) {
                  //initialize required fields map
                  String encounterType = object.getString(ConstantsUtils.JsonFormKeyUtils.ENCOUNTER_TYPE);
      
      

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

                if (StringUtils.isNotBlank(alertStatus) && !isProfile) {
                    switch (alertStatus) {
                        case ConstantsUtils.AlertStatusUtils.IN_PROGRESS:
                            displayTemplate = context.getString(R.string.contact_in_progress);
                            break;
        opensrp-anc/src/main/java/org/smartregister/anc/library/util/Utils.java on lines 503..515

        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 78.

        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

                } else {
                    switch (alertStatus) {
                        case ConstantsUtils.AlertStatusUtils.IN_PROGRESS:
                            displayTemplate = context.getString(R.string.contact_in_progress_no_break);
                            break;
        opensrp-anc/src/main/java/org/smartregister/anc/library/util/Utils.java on lines 491..503

        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 78.

        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

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

                if (fieldObject.has(JsonFormConstants.VALUE) && !TextUtils.isEmpty(fieldObject.getString(JsonFormConstants.VALUE)) &&
                        fieldObject.getString(ConstantsUtils.KeyUtils.KEY).endsWith(ConstantsUtils.SuffixUtils.OTHER) && facts.get(
                        fieldObject.getString(ConstantsUtils.KeyUtils.KEY).replace(ConstantsUtils.SuffixUtils.OTHER, ConstantsUtils.SuffixUtils.VALUE)) != null) {
        opensrp-anc/src/main/java/org/smartregister/anc/library/activity/MainContactActivity.java on lines 426..429

        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 78.

        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

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

                if (fieldObject.has(JsonFormConstants.VALUE) && !TextUtils.isEmpty(fieldObject.getString(JsonFormConstants.VALUE)) &&
                        fieldObject.getString(ConstantsUtils.KeyUtils.KEY).endsWith(ConstantsUtils.SuffixUtils.OTHER) && formGlobalValues
                        .get(fieldObject.getString(ConstantsUtils.KeyUtils.KEY).replace(ConstantsUtils.SuffixUtils.OTHER, ConstantsUtils.SuffixUtils.VALUE)) !=
                        null) {
        opensrp-anc/src/main/java/org/smartregister/anc/library/util/ANCFormUtils.java on lines 362..364

        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 78.

        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 createVisitAndUpdateEvent has 28 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            public static Pair<Event, Event> createVisitAndUpdateEvent(List<String> formSubmissionIDs,
                                                                       Map<String, String> womanDetails) {
                if (formSubmissionIDs.size() < 1 && womanDetails.get(ConstantsUtils.REFERRAL) == null) {
                    return null;
                }

          Method createSavePdf has 28 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              public void createSavePdf(Context context, List<YamlConfig> yamlConfigList, Facts facts,String womanName) throws FileNotFoundException {
          
                  String FILENAME = womanName+"_"+context.getResources().getString(R.string.contact_summary_data_file);
                  String filePath = getAppPath(context) + FILENAME;
          
          

            Method initializeFirstContactValues has 28 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                private static String initializeFirstContactValues(@NonNull JSONArray fields) throws JSONException {
                    String strGroup = null;
            
                    int nextContact = 1;
            
            

              Method getImmediatePreviousContact has 28 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  @Override
                  public Facts getImmediatePreviousContact(Map<String, String> clientDetails, String baseEntityId, String contactNo) {
                      Facts facts = new Facts();
                      try {
                          facts = AncLibrary.getInstance().getPreviousContactRepository().getPreviousContactFacts(baseEntityId, contactNo, true);

                Method getImmediatePreviousSchedule has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    public Facts getImmediatePreviousSchedule(String baseEntityId, String contactNo) {
                        Cursor scheduleCursor = null;
                        String selection = "";
                        String orderBy = "created_at DESC";
                        String[] selectionArgs = null;

                  Method getPreviousContactTestsFacts has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      public Facts getPreviousContactTestsFacts(String baseEntityId) {
                          Cursor mCursor = null;
                          Facts previousContactsTestsFacts = new Facts();
                          try {
                              SQLiteDatabase db = getWritableDatabase();

                    Method getPartialContacts has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        public List<PartialContact> getPartialContacts(String baseEntityId, Integer contactNumber) {
                            Cursor mCursor = null;
                            String selection = "";
                            String[] selectionArgs = null;
                            List<PartialContact> partialContactList = null;

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

                                              while (keys.hasNext()) {
                                                  String key = keys.next();
                                                  String valueObject = jsonObject.optString(key), value;
                                                  value = Utils.returnTranslatedStringJoinedValue(valueObject);
                                                  if (StringUtils.isNotBlank(value)) {
                      opensrp-anc/src/main/java/org/smartregister/anc/library/presenter/ProfileFragmentPresenter.java on lines 73..82

                      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 76.

                      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

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

                                          while (keys.hasNext()) {
                                              String key = keys.next();
                                              String valueObject = jsonObject.optString(key), value;
                                              value = Utils.returnTranslatedStringJoinedValue(valueObject);
                                              if (StringUtils.isNotBlank(value)) {
                      opensrp-anc/src/main/java/org/smartregister/anc/library/activity/PreviousContactsDetailsActivity.java on lines 157..166

                      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 76.

                      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 getFormAsJson has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                      Open

                          public static JSONObject getFormAsJson(JSONObject form, String formName, String id, String currentLocationId)
                                  throws Exception {
                              if (form == null) {
                                  return null;
                              }

                      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 populatePatientColumn has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                      Open

                          private void populatePatientColumn(CommonPersonObjectClient pc, SmartRegisterClient client,
                                                             RegisterViewHolder viewHolder) {
                      
                              String firstName = Utils.getValue(pc.getColumnmaps(), DBConstantsUtils.KeyUtils.FIRST_NAME, true);
                              String lastName = Utils.getValue(pc.getColumnmaps(), DBConstantsUtils.KeyUtils.LAST_NAME, true);

                      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 initializeFirstContactValues has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                      Open

                          private static String initializeFirstContactValues(@NonNull JSONArray fields) throws JSONException {
                              String strGroup = null;
                      
                              int nextContact = 1;
                      
                      

                      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 saveImage has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                      Open

                          public static void saveImage(String providerId, String entityId, String imageLocation) {
                              OutputStream outputStream = null;
                              try {
                                  if (StringUtils.isBlank(imageLocation)) {
                                      return;

                      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

                      Severity
                      Category
                      Status
                      Source
                      Language