microting/eform-sdk-dotnet

View on GitHub
eFormCore/Communication/Communicator.cs

Summary

Maintainability
F
6 days
Test Coverage

File Communicator.cs has 689 lines of code (exceeds 250 allowed). Consider refactoring.
Open

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microting.eForm.Dto;
Severity: Major
Found in eFormCore/Communication/Communicator.cs - About 1 day to fix

    Class Communicator has 50 methods (exceeds 20 allowed). Consider refactoring.
    Open

        public class Communicator
        {
            #region var
    
            //SqlController sqlController;
    Severity: Minor
    Found in eFormCore/Communication/Communicator.cs - About 7 hrs to fix

      Method SiteCreate has 32 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              public async Task<Tuple<SiteDto, UnitDto>> SiteCreate(string name, string languageCode)
              {
                  _log.LogEverything("Communicator.SiteCreate", "called");
                  _log.LogVariable("Communicator.SiteCreate", nameof(name), name);
      
      
      Severity: Minor
      Found in eFormCore/Communication/Communicator.cs - About 1 hr to fix

        Method OrganizationLoadAllFromRemote has 30 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

                public async Task<OrganizationDto> OrganizationLoadAllFromRemote(string token)
                {
                    _log.LogEverything("Communicator.OrganizationLoadAllFromRemote", "called");
                    _log.LogVariable("Communicator.OrganizationLoadAllFromRemote", nameof(token), token);
                    IHttp specialHttp;
        Severity: Minor
        Found in eFormCore/Communication/Communicator.cs - About 1 hr to fix

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

                  public async Task<string> EntityGroupCreate(string entityType, string name, string id)
                  {
                      _log.LogEverything("Communicator.EntityGroupCreate", "called");
                      _log.LogVariable("Communicator.EntityGroupCreate", nameof(entityType), entityType);
                      _log.LogVariable("Communicator.EntityGroupCreate", nameof(name), name);
          Severity: Minor
          Found in eFormCore/Communication/Communicator.cs - About 1 hr to fix

            Method EntityGroupUpdate has 27 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    public async Task<bool> EntityGroupUpdate(string entityType, string name, int id, string entityGroupMuId)
                    {
                        _log.LogEverything("Communicator.EntityGroupUpdate", "called");
                        _log.LogVariable("Communicator.EntityGroupUpdate", nameof(entityType), entityType);
                        _log.LogVariable("Communicator.EntityGroupUpdate", nameof(name), name);
            Severity: Minor
            Found in eFormCore/Communication/Communicator.cs - About 1 hr to fix

              Method UnitRequestOtp has 6 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                      public Task<string> UnitRequestOtp(int microtingUid, int siteId, bool newOtp, bool pushEnabled,
                          bool syncDelayEnabled, bool syncDialogEnabled)
              Severity: Minor
              Found in eFormCore/Communication/Communicator.cs - About 45 mins to fix

                Method EntitySearchItemUpdate has 5 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                        public Task<bool> EntitySearchItemUpdate(string entitySearchGroupId, string entitySearchItemId, string name,
                            string description, string id)
                Severity: Minor
                Found in eFormCore/Communication/Communicator.cs - About 35 mins to fix

                  Method EntitySelectItemUpdate has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                          public Task<bool> EntitySelectItemUpdate(string entitySearchGroupId, string entitySearchItemId, string name,
                              int displayOrder, string ownUUID)
                  Severity: Minor
                  Found in eFormCore/Communication/Communicator.cs - About 35 mins to fix

                    Method FolderUpdate has 5 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                            public Task FolderUpdate(int id, string name, string description, string languageCode, int? parentId)
                    Severity: Minor
                    Found in eFormCore/Communication/Communicator.cs - About 35 mins to fix

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

                              public Task<bool> EntitySearchItemUpdate(string entitySearchGroupId, string entitySearchItemId, string name,
                                  string description, string id)
                              {
                                  _log.LogEverything("Communicator.EntitySearchItemUpdate", "called");
                                  _log.LogVariable("Communicator.EntitySearchItemUpdate", nameof(entitySearchGroupId), entitySearchGroupId);
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 2 hrs to fix
                      eFormCore/Communication/Communicator.cs on lines 754..765

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

                      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

                              public Task<bool> EntitySelectItemUpdate(string entitySearchGroupId, string entitySearchItemId, string name,
                                  int displayOrder, string ownUUID)
                              {
                                  _log.LogEverything("Communicator.EntitySelectItemUpdate", "called");
                                  _log.LogVariable("Communicator.EntitySelectItemUpdate", nameof(entitySearchGroupId), entitySearchGroupId);
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 2 hrs to fix
                      eFormCore/Communication/Communicator.cs on lines 707..718

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

                      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

                              public async Task<string> EntitySearchItemCreate(string entitySearchGroupId, string name, string description,
                                  string id)
                              {
                                  _log.LogEverything("Communicator.EntitySearchItemCreate", "called");
                                  _log.LogVariable("Communicator.EntitySearchItemCreate", nameof(entitySearchGroupId), entitySearchGroupId);
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 2 hrs to fix
                      eFormCore/Communication/Communicator.cs on lines 735..752

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

                      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

                              public async Task<string> EntitySelectItemCreate(string entitySearchGroupId, string name, int displayOrder,
                                  string ownUUID)
                              {
                                  _log.LogEverything("Communicator.EntitySelectItemCreate", "called");
                                  _log.LogVariable("Communicator.EntitySelectItemCreate", nameof(entitySearchGroupId), entitySearchGroupId);
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 2 hrs to fix
                      eFormCore/Communication/Communicator.cs on lines 688..705

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

                      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

                              public async Task<bool> UnitDelete(int unitId)
                              {
                                  _log.LogEverything("Communicator.UnitDelete", "called");
                                  _log.LogVariable("Communicator.UnitDelete", nameof(unitId), unitId);
                      
                      
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 1 hr to fix
                      eFormCore/Communication/Communicator.cs on lines 312..326

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

                      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

                              public async Task<bool> SiteDelete(int siteId)
                              {
                                  _log.LogEverything("Communicator.SiteDelete", "called");
                                  _log.LogVariable("Communicator.SiteDelete", nameof(siteId), siteId);
                      
                      
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 1 hr to fix
                      eFormCore/Communication/Communicator.cs on lines 450..464

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

                      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

                              public async Task<bool> WorkerDelete(int workerId)
                              {
                                  _log.LogEverything("Communicator.WorkerDelete", "called");
                                  _log.LogVariable("Communicator.WorkerDelete", nameof(workerId), workerId);
                      
                      
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 1 hr to fix
                      eFormCore/Communication/Communicator.cs on lines 409..420

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

                      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

                              public async Task<bool> SiteWorkerDelete(int workerId)
                              {
                                  _log.LogEverything("Communicator.SiteWorkerDelete", "called");
                                  _log.LogVariable("Communicator.SiteWorkerDelete", nameof(workerId), workerId);
                      
                      
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 1 hr to fix
                      eFormCore/Communication/Communicator.cs on lines 373..384

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

                      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

                              public Task<string> CheckStatus(string eFormId, int siteId)
                              {
                                  _log.LogEverything("Communicator.CheckStatus", "called");
                                  _log.LogVariable("Communicator.CheckStatus", nameof(eFormId), eFormId);
                                  _log.LogVariable("Communicator.CheckStatus", nameof(siteId), siteId);
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 1 hr to fix
                      eFormCore/Communication/Communicator.cs on lines 249..256

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

                      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

                              public Task<string> Delete(string eFormId, int siteId)
                              {
                                  _log.LogEverything("Communicator.Delete", "called");
                                  _log.LogVariable("Communicator.Delete", nameof(eFormId), eFormId);
                                  _log.LogVariable("Communicator.Delete", nameof(siteId), siteId);
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 1 hr to fix
                      eFormCore/Communication/Communicator.cs on lines 156..163

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

                      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

                              public async Task<bool> EntitySelectItemDelete(string entitySearchItemId)
                              {
                                  _log.LogEverything("Communicator.EntitySelectItemDelete", "called");
                                  _log.LogVariable("Communicator.EntitySelectItemDelete", nameof(entitySearchItemId), entitySearchItemId);
                      
                      
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 1 hr to fix
                      eFormCore/Communication/Communicator.cs on lines 720..733

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

                      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

                              public async Task<bool> EntitySearchItemDelete(string entitySearchItemId)
                              {
                                  _log.LogEverything("Communicator.EntitySearchItemDelete", "called");
                                  _log.LogVariable("Communicator.EntitySearchItemDelete", nameof(entitySearchItemId), entitySearchItemId);
                      
                      
                      Severity: Major
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 1 hr to fix
                      eFormCore/Communication/Communicator.cs on lines 767..780

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

                      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

                              public async Task<string> GetQuestionSet(int id)
                              {
                                  _log.LogEverything("Communicator.GetQuestionSet", "called");
                      
                                  try
                      Severity: Minor
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 40 mins to fix
                      eFormCore/Communication/Communicator.cs on lines 898..910

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

                      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

                              public async Task<string> GetSurveyConfiguration(int id)
                              {
                                  _log.LogEverything("Communicator.GetSurveyConfiguration", "called");
                      
                                  try
                      Severity: Minor
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 40 mins to fix
                      eFormCore/Communication/Communicator.cs on lines 930..942

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

                      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

                              public async Task<string> GetAllSurveyConfigurations()
                              {
                                  _log.LogEverything("Communicator.GetAllSurveyConfigurations", "called");
                      
                                  try
                      Severity: Minor
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 35 mins to fix
                      eFormCore/Communication/Communicator.cs on lines 916..928

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

                      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

                              public async Task<string> GetAllQuestionSets()
                              {
                                  _log.LogEverything("Communicator.GetAllQuestionSets", "called");
                      
                                  try
                      Severity: Minor
                      Found in eFormCore/Communication/Communicator.cs and 1 other location - About 35 mins to fix
                      eFormCore/Communication/Communicator.cs on lines 884..896

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

                      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

                      There are no issues that match your filters.

                      Category
                      Status