Anapher/Strive

View on GitHub

Showing 250 of 735 total issues

Function WebcamSettings has 27 lines of code (exceeds 25 allowed). Consider refactoring.
Open

export default function WebcamSettings() {
   const classes = useStyles();
   const { t } = useTranslation();
   const selectedDevice = useSelector((state: RootState) => state.settings.obj.webcam.device);
   const availableDevices = useSelectorFactory(selectAvailableInputDevicesFactory, (state: RootState, selector) =>

    Function transportProduce has 27 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

       public async transportProduce(
          { transportId, appData, kind, ...producerOptions }: TransportProduceRequest,
          connectionId: string,
       ): Promise<SuccessOrError<TransportProduceResponse>> {
          const connection = this.connections.get(connectionId);
    Severity: Minor
    Found in src/Services/SFU/src/lib/conference/conference.ts - About 1 hr to fix

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

              public async Task<SuccessOrError<Unit>> Handle(SetTemporaryPermissionRequest request,
                  CancellationToken cancellationToken)
              {
                  var (participant, permissionKey, value) = request;
      
      

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

                public async Task<Unit> Handle(TalkingStickEnqueueRequest request, CancellationToken cancellationToken)
                {
                    var (participant, remove) = request;
        
                    var rooms = await _mediator.FetchSynchronizedObject<SynchronizedRooms>(participant.ConferenceId,

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

                  public IEnumerable<ClusterBucket<T>> BuildCluster<T, TValue>(IEnumerable<T> data, Func<T, TValue> valueSelector,
                      IDistanceAlgorithm<TValue> distanceAlgorithm, double threshold)
                  {
                      var clusterBuckets = data.Select(x => new ClusterBucket<T>(new List<T> {x})).ToArray();
                      var entriesMatrix = new double?[clusterBuckets.Length, clusterBuckets.Length];

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

                    [Fact]
                    public async Task GlobalUndo_IsAvailable_ExecuteUndo()
                    {
                        // arrange
                        var useCase = Create();

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

                      public async Task<Unit> Handle(UpdateSubscriptionsRequest request, CancellationToken cancellationToken)
                      {
                          var participant = request.Participant;
              
                          _logger.LogDebug("Update subscriptions for {participant}", participant);

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

                        public async Task<SuccessOrError<Unit>> Handle(OpenBreakoutRoomsRequest request,
                            CancellationToken cancellationToken)
                        {
                            var (_, _, _, assignedRooms, conferenceId) = request;
                
                

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

                          public async Task<SuccessOrError<TResponse>> Send()
                          {
                              var token = _context.Hub.Context.ConnectionAborted;
                  
                              foreach (var middleware in _middlewares)

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

                            [HttpPatch("{conferenceId}")]
                            [Authorize]
                            public async Task<ActionResult> PatchConferenceLink(string conferenceId,
                                JsonPatchDocument<ChangeConferenceLinkStarDto> patch, [FromServices] IConferenceLinkRepo repo,
                                [FromServices] IOptions<ConcurrencyOptions> options)

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

                              [Fact]
                              public async Task GlobalRedo_IsAvailable_ExecuteRedo()
                              {
                                  // arrange
                                  var useCase = Create();

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

                                [Fact]
                                public async Task DisposeAsync_ThreadSafety()
                                {
                                    // arrange
                                    var readerWriterLock = new AsyncReaderWriterLock();

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

                                  private async Task<LoginViewModel> BuildLoginViewModelAsync(string returnUrl)
                                  {
                                      var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
                                      if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
                                      {

                            Function getStatusMessage has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            export const getStatusMessage: (health: WebRtcHealth, t: TFunction<'translation'>) => string = (health, t) => {
                               if (health.connection?.status === 'ok' && health.connector.status === 'ok')
                                  return t(`${webRtcNamespace}.connected.message`);
                            
                               if (health.connector.status !== 'ok') {

                              Function SceneLayoutSelect has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                              export default function SceneLayoutSelect(props: React.ComponentProps<typeof Select>) {
                                 const { t } = useTranslation();
                              
                                 return (
                                    <>

                                Method TalkingStick_Race_PresenterLeaves_RemoveScene has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                        [Fact]
                                        public async Task TalkingStick_Race_PresenterLeaves_RemoveScene()
                                        {
                                            // arrange
                                            var (conn, conference) = await ConnectToOpenedConference();

                                  Method Handle has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                          public async Task<Unit> Handle(SetParticipantRoomRequest request, CancellationToken cancellationToken)
                                          {
                                              var (conferenceId, assignments) = request;
                                  
                                              var changedRooms = new Dictionary<Participant, ParticipantRoomChangeInfo>();

                                    Method BuildLoggedOutViewModelAsync has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                            private async Task<LoggedOutViewModel> BuildLoggedOutViewModelAsync(string logoutId)
                                            {
                                                // get context information (client name, post logout redirect URI and iframe for federated signout)
                                                var logout = await _interaction.GetLogoutContextAsync(logoutId);
                                    
                                    

                                      Method Main has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                              public static int Main(string[] args)
                                              {
                                                  Log.Logger = new LoggerConfiguration()
                                                      .MinimumLevel.Debug()
                                                      .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
                                      Severity: Minor
                                      Found in src/Services/Identity/Identity.API/Program.cs - About 1 hr to fix

                                        Method RemoveParticipantTypingAfter_AddMultiple_SendAllRequests has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                                [Fact]
                                                public async Task RemoveParticipantTypingAfter_AddMultiple_SendAllRequests()
                                                {
                                                    // arrange
                                                    var timer = Create();
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language