private void VideosListView_SelectedIndexChanged(object sender, EventArgs e) { if (VideosListView.SelectedItems.Count == 1) { Database.Types.Video selectedVideo = (Database.Types.Video)VideosListView.SelectedItems[0].Tag; string openVideoTip = $"Open video in browser.{Environment.NewLine}{selectedVideo.URL}"; VideoPictureBox.Image = Database.ImageFile.Get(selectedVideo.ID, ImageType.VideoThumbnail); VideoPictureBox.Visible = true; GeneralToolTip.SetToolTip(VideoPictureBox, openVideoTip); VideoDescriptionLabel.Text = StringUtils.FormatVideoDescription(selectedVideo.Description); VideoLinkLabel.Tag = selectedVideo.URL; VideoLinkLabel.Text = selectedVideo.Title; GeneralToolTip.SetToolTip(VideoLinkLabel, openVideoTip); PostedLabel.Text = selectedVideo.Posted.Value.ToString(); DurationLabel.Text = TimeSpanUtils.ConvertDuration(selectedVideo.Duration); VideoInfoPanel.Visible = true; } else { VideosListViewChanged(); } }
/// <summary> /// Get information about a single video. /// </summary> /// <param name="id">ID of the video to get information for.</param> public Database.Types.Video Single(string id) { try { // https://developers.google.com/youtube/v3/docs/videos/list API.VideosResource.ListRequest videoSearch = APIService.Videos.List("id,snippet,contentDetails.duration"); videoSearch.Id = id; videoSearch.MaxResults = 1; videoSearch.PrettyPrint = false; API.Data.Video response = videoSearch.Execute().Items[0]; Database.Types.Video video = new Database.Types.Video { ID = response.Id, ChannelID = response.Snippet.ChannelId, Title = response.Snippet.Title, Description = response.Snippet.Description, Duration = TimeSpanUtils.ConvertDuration(response.ContentDetails.Duration), Posted = DateTime.Parse(response.Snippet.PublishedAt), ThumbnailURL = GetBestThumbnail(response.Snippet.Thumbnails), WatchStatus = WatchStatus.Unwatched }; LoggingManager.Log.Info($"Information processed for '{video.ID}' posted by '{video.ChannelID}'."); return(video); } catch (Exception ex) { LoggingManager.Log.Error(ex, $"Failed to get information for '{id}'."); return(null); } }
public void Parse_HoursMinutesSeconds_Test() { var expected = TimeSpan.Parse("0.12:23:59"); var actual = TimeSpanUtils.Parse("12:23:59"); Assert.Equal(expected, actual); }
public void Parse_DaysHoursMinutesSecondsMilliseconds_Test() { var expected = TimeSpan.Parse("12.23:54:59.999"); var actual = TimeSpanUtils.Parse("12:23:54:59:999"); Assert.Equal(expected, actual); }
public void Parse_InvalidString_Test() { var expected = TimeSpan.Parse("0.00:00:00.000"); var actual = TimeSpanUtils.Parse("wefwef"); Assert.Equal(expected, actual); }
public void Parse_Ticks_Test() { var expected = TimeSpan.Parse("0.00:00:00.0000012"); var actual = TimeSpanUtils.Parse("12"); Assert.Equal(expected, actual); }
/// <summary> /// Wait for an event flag for a given bit pattern with callback. /// </summary> /// <param name="EventId">The event id returned by sceKernelCreateEventFlag.</param> /// <param name="Bits">The bit pattern to poll for.</param> /// <param name="Wait">Wait type, one or more of ::PspEventFlagWaitTypes or'ed together</param> /// <param name="OutBits">The bit pattern that was matched.</param> /// <param name="Timeout">Timeout in microseconds</param> /// <param name="HandleCallbacks"></param> /// <returns> /// ERROR_KERNEL_NOT_FOUND_EVENT_FLAG - If can't find the eventFlag /// ERROR_KERNEL_WAIT_TIMEOUT - If there was a timeout /// 0 - On success /// </returns> public int _sceKernelWaitEventFlagCB(EventFlagId EventId, uint Bits, EventFlagWaitTypeSet Wait, uint *OutBits, uint *Timeout, bool HandleCallbacks) { var EventFlag = HleState.EventFlagManager.EventFlags.Get(EventId); bool TimedOut = false; HleState.ThreadManager.Current.SetWaitAndPrepareWakeUp(HleThread.WaitType.Semaphore, String.Format("_sceKernelWaitEventFlagCB(EventId={0}, Bits={1:X}, Wait={2})", EventId, Bits, Wait), WakeUpCallback => { if (Timeout != null) { HleState.PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(*Timeout), () => { TimedOut = true; WakeUpCallback(); }); } EventFlag.AddWaitingThread(new HleEventFlag.WaitThread() { HleThread = HleState.ThreadManager.Current, BitsToMatch = Bits, WaitType = Wait, WakeUpCallback = () => { WakeUpCallback(); }, OutBits = OutBits, }); }, HandleCallbacks: HandleCallbacks); if (TimedOut) { throw(new SceKernelException(SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT)); } //throw(new NotImplementedException()); return(0); }
public int sceKernelReceiveMbx(MessageBox MessageBox, PspPointer *PointerToMessage, uint *Timeout) { var CurrentThread = ThreadManager.Current; bool TimedOut = false; CurrentThread.SetWaitAndPrepareWakeUp(HleThread.WaitType.None, "sceKernelReceiveMbx", MessageBox, WakeUpCallback => { if (Timeout != null) { PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(*Timeout), () => { TimedOut = true; WakeUpCallback(); }); } MessageBox.Receive(PointerToMessage, WakeUpCallback); }, HandleCallbacks: false); if (TimedOut) { return((int)SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT); } else { //if (Timeout) //return MessageBox.Receive(Message); return(0); } }
public void RegisterTimeout(uint *timeout, Action wakeUpCallback) { if (timeout != null) { RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(*timeout), wakeUpCallback); } }
/// <summary> /// Get the timeout to wait for the next possible logging event, ensuring that /// the time doesn't cause events in the buffer to be sent from being delayed /// once the holddown timeout expires. /// </summary> private TimeSpan GetWaitTimeOut(WorkerState state) { DateTime now = DateTime.UtcNow; var maxHolddownInterval = TimeSpanUtils.Max(state.LastSend + HolddownPeriod - now, TimeSpan.Zero); return(new TimeSpan(0, 0, 30)); }
protected void UpdateHandlerTime() { PspRtc.Update(); Console.Error.WriteLine("UpdateHandlerTime: {0}", this.HandlerTime - ElapsedAccumulatedTime); this.Timer.DateTime = PspRtc.CurrentDateTime + TimeSpanUtils.FromMicroseconds(this.HandlerTime - ElapsedAccumulatedTime); }
public void Send(int id, string name, LuaTable tb) { if (SocketClient.State == SocketClient.ConnectState.DisConnect) { return; } var msg = ProtocolGroup.GetMsg(name); if (msg == null) { Debug.Log(String.Format("protocol {0} not exist", name)); return } m_messageIndex++; ByteBuffer protoBuff = new ByteBuffer(); ProtocolReadWriter.Req(msg.Id, buff, tb, ProtocolGroup); byteBuffer buff = new ByteBuffer(); buff.WriteUshort(msg.Id); buff.WriteBytes(protoBuff.ToBytes()); protoBuff.Close(); byte[] buffBytes = buff.ToBytes(); ByteBuffer contentBuff = new ByteBuffer(); contentBuff.WriteVchar((uint)buffBytes.Length); contentBuff.WriteBytes(buffBytes); ByteBuffer sendBuff = new ByteBuffer(); sendBuff.WriteUint(Convert.ToUInt32(buffBytes.Length) + 16); //CRC uint crc = CRC.GetCrc32(buffBytes); sendBuffer.WriteUint(crc); //Time uint timeUint = TimeSpanUtils.ConvertDateTimeToUInt(DateTime.Now); ByteBuffer desBuff = new ByteBuffer(); desBuff.WriteBytes(BitConverter.GetBytes(timeUint)); desBuff.WriteBytes(BitConverter.GetBytes(m_messageIndex)); //DES ulong des = BitConverter.ToUInt64(desBuff.ToBytes(), 0); byte[] desBytes = DES.Encrypt(bitConverter.GetBytes(des)); sendBuff.WriteUlong(BitConverter.ToUInt64(desBytes, 0)); sendBuff.WriteBytes(buffBytes); client.SendMessage(sendBuff); contentBuff.Close(); desBuff.Close(); buff.Close(); }
private void UpdateDuration(SyncOperationStatus status) { Assert.IsNotNull(RunningOperation); var duration = !status.IsEnded() || !RunningOperation.FinishedAt.HasValue ? DateTime.UtcNow - RunningOperation.StartedAt.Value : RunningOperation.FinishedAt.Value - RunningOperation.StartedAt.Value; lblDuration.Text = TimeSpanUtils.GetReadableTimespan(duration); }
private void LogEnd() { logger.Info( #if DEBUG "{0}:{1}:{2} - ENDED {3} - TOOK {4}", #else "{2} - ENDED {3} - TOOK {4}", #endif SourceFilePath, SourceLineNumberCreated, MemberName, Identifier, TimeSpanUtils.GetReadableTimespan(Duration)); }
/// <summary> /// Wait for an event flag for a given bit pattern with callback. /// </summary> /// <param name="EventId">The event ID returned by <see cref="sceKernelCreateEventFlag"/>.</param> /// <param name="Bits">The bit pattern to poll for.</param> /// <param name="Wait">Wait type, one or more of PspEventFlagWaitTypes or'ed together</param> /// <param name="OutBits">The bit pattern that was matched.</param> /// <param name="Timeout">Timeout in microseconds</param> /// <param name="HandleCallbacks"></param> /// <returns> /// ERROR_KERNEL_NOT_FOUND_EVENT_FLAG - If can't find the eventFlag /// ERROR_KERNEL_WAIT_TIMEOUT - If there was a timeout /// 0 - On success /// </returns> public int _sceKernelWaitEventFlagCB(HleEventFlag EventFlag, uint Bits, EventFlagWaitTypeSet Wait, uint *OutBits, uint *Timeout, bool HandleCallbacks) { if ((Wait & ~EventFlagWaitTypeSet.MaskValidBits) != 0) { throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_ILLEGAL_MODE); } if (Bits == 0) { throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_EVENT_FLAG_ILLEGAL_WAIT_PATTERN); } bool TimedOut = false; var PreviousPattern = EventFlag.Info.CurrentPattern; ThreadManager.Current.SetWaitAndPrepareWakeUp( HleThread.WaitType.Semaphore, $"_sceKernelWaitEventFlagCB(EventId={EventFlag.GetUidIndex(InjectContext)}, Bits={Bits:X}, Wait={Wait})", EventFlag, WakeUpCallback => { if (Timeout != null) { PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(*Timeout), () => { TimedOut = true; *Timeout = 0; WakeUpCallback(); }); } EventFlag.AddWaitingThread(new HleEventFlag.WaitThread() { HleThread = ThreadManager.Current, BitsToMatch = Bits, WaitType = Wait, WakeUpCallback = () => { WakeUpCallback(); }, OutBits = OutBits, }); }, HandleCallbacks: HandleCallbacks); if (OutBits != null) { *OutBits = PreviousPattern; } if (TimedOut) { throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT); } //throw(new NotImplementedException()); return(0); }
private int _sceKernelDelayThreadCB(uint DelayInMicroseconds, bool HandleCallbacks) { HleState.ThreadManager.Current.SetWaitAndPrepareWakeUp(HleThread.WaitType.Timer, "sceKernelDelayThread", WakeUpCallback => { HleState.PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(DelayInMicroseconds), () => { WakeUpCallback(); }); }, HandleCallbacks: HandleCallbacks); return(0); }
/// <summary> /// /// </summary> /// <param name="ThreadId"></param> /// <param name="Timeout"></param> /// <param name="HandleCallbacks"></param> /// <returns></returns> private int _sceKernelWaitThreadEndCB(int ThreadId, uint *Timeout, bool HandleCallbacks) { var ThreadToWaitEnd = GetThreadById(ThreadId); if (ThreadToWaitEnd.HasAnyStatus(HleThread.Status.Stopped)) { return(0); } if (ThreadToWaitEnd.HasAnyStatus(HleThread.Status.Killed)) { return(0); } bool TimedOut = false; ThreadManager.Current.SetWaitAndPrepareWakeUp(HleThread.WaitType.None, $"sceKernelWaitThreadEnd('{ThreadToWaitEnd.Name}')", ThreadToWaitEnd, WakeUpCallback => { if (Timeout != null) { PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(*Timeout), () => { TimedOut = true; WakeUpCallback(); }); } Console.WriteLine("Wait End!"); Action OnTerminate = null; OnTerminate = () => { ThreadToWaitEnd.OnTerminate -= OnTerminate; Console.WriteLine("Ended!"); //throw(new Exception("aaaaaaaaaaaa")); WakeUpCallback(); }; ThreadToWaitEnd.OnTerminate += OnTerminate; }, HandleCallbacks: HandleCallbacks); if (TimedOut) { return((int)SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT); } else { return(0); } }
private int _sceKernelDelayThreadCB(uint DelayInMicroseconds, bool HandleCallbacks) { var CurrentThread = ThreadManager.Current; CurrentThread.SetWaitAndPrepareWakeUp(HleThread.WaitType.Timer, $"sceKernelDelayThread({DelayInMicroseconds}, {HandleCallbacks})", null, WakeUpCallback => { PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(DelayInMicroseconds), () => { WakeUpCallback(); }); }, HandleCallbacks: HandleCallbacks); return(0); }
private void UpdateDuration(Commands.OperationStatus status) { // Prevent a NPE when accessing `CurrentOperation.StartedAt` below. if (!CurrentOperation.GotInitialInfo) { return; } // Calculate duration. var duration = !status.IsEnded() || !CurrentOperation.FinishedAt.HasValue ? DateTime.UtcNow - CurrentOperation.StartedAt.Value : CurrentOperation.FinishedAt.Value - CurrentOperation.StartedAt.Value; lblDuration.Text = TimeSpanUtils.GetReadableTimespan(duration); }
private static IEnumerable <MatchEvent> ConvertTimeEventsDtoToTimelineEvents( IEnumerable <MatchEventDto> matchEventDtoList) { if (matchEventDtoList == null) { return(new List <MatchEvent>()); } try { var matchEventList = new List <MatchEvent>(); foreach (var matchEventDto in matchEventDtoList) { matchEventList.Add(new MatchEvent { Type = matchEventDto.Type, TimeStamp = matchEventDto.Timestamp, UserFriendlyTimestamp = TimeSpanUtils.ConvertTimespanToFriendly(Convert.ToInt32(matchEventDto.Timestamp.TotalSeconds)), ParticipantId = matchEventDto.ParticipantId, ItemId = matchEventDto.ItemId, SkillSlot = matchEventDto.SkillSlot, LevelUpType = matchEventDto.LevelUpType, WardType = matchEventDto.WardType, CreatorId = matchEventDto.CreatorId, KillerId = matchEventDto.KillerId, VictimId = matchEventDto.VictimId, AfterId = matchEventDto.AfterId, BeforeId = matchEventDto.BeforeId, TeamId = matchEventDto.TeamId, BuildingType = matchEventDto.BuildingType, LaneType = matchEventDto.LaneType, TowerType = matchEventDto.TowerType, MonsterType = matchEventDto.MonsterType, MonsterSubType = matchEventDto.MonsterSubType }); } return(matchEventList); } catch (Exception e) { Console.WriteLine("Exception caught when converting list of MatchEventDto to list of MatchEvent : " + e.Message); } return(new List <MatchEvent>()); }
public NotificationForm(Database.Types.Video video) { InitializeComponent(); SetIcon(); if (SettingsManager.Configuration.NotificationWindow.PositionSet()) { Location = new Point(SettingsManager.Configuration.NotificationWindow.X, SettingsManager.Configuration.NotificationWindow.Y); } else { CenterToScreen(); } _Video = video; Image channelImage = Database.ImageFile.Get(_Video.ChannelID, ImageType.ChannelIcon); Image channelImageResized = ImageUtils.ResizeImage(channelImage, 365, 365); Image channelImageFaded = ImageUtils.SetImageOpacity(channelImageResized, 0.16f); BackgroundImage = channelImageFaded; ChannelPictureBox.Image = channelImage; VideoPictureBox.Image = Database.ImageFile.Get(_Video.ID, ImageType.VideoThumbnail); ChannelLabel.Text = $"A new video was posted by {_Video.Channel.Title} {_Video.Posted.Value.Humanize()}."; DurationLabel.Text = TimeSpanUtils.ConvertDurationCompact(video.Duration); MarkButton.Text = $"Close & mark as: (wait {(_Countdown + 1)}s)"; OpenVideoCheckBox.Checked = SettingsManager.Configuration.NotificationOpenVideo; OpenVideoStatusComboBox.Items.Add(WatchStatus.Unwatched); OpenVideoStatusComboBox.Items.Add(WatchStatus.Watched); OpenVideoStatusComboBox.Items.Add(WatchStatus.Dismissed); OpenVideoStatusComboBox.Items.Add(WatchStatus.Ignored); OpenVideoStatusComboBox.SelectedItem = SettingsManager.Configuration.NotificationDefaultVideoStatus; ControlBox = false; }
public static Match ConverMatchDtoToMatch(MatchDto matchDto, MatchTimelineDto matchTimelineDto) { if (matchDto == null || matchTimelineDto == null) { return(new Match()); } try { return(new Match { GameDuration = TimeSpanUtils.ConvertTimespanToFriendly(Convert.ToInt32(matchDto.GameDuration.TotalSeconds)), GameDate = matchDto.GameDate, GamePatch = matchDto.GamePatch, WinningTeamId = matchDto.WinningTeamId, TeamOne = ConvertMatchTeamDtoToMatchTeam ( matchDto.Teams.ElementAtOrDefault(0), matchTimelineDto.Events ), TeamTwo = ConvertMatchTeamDtoToMatchTeam ( matchDto.Teams.ElementAtOrDefault(1), matchTimelineDto.Events ) }); } catch (Exception e) { Console.WriteLine("Exception caught converting MatchDto to Match : " + e.Message); } return(new Match()); }
public void CalcularClassificacaoFinalPilotos(Dictionary <int, DadosCorridaPiloto> pPosicaoFinal) { StringBuilder classificacaoFinal = new StringBuilder(); var formatString = "|{0,-30}|{1,-30}|{2,-30}|{3,-30}|{4,-30}|{5,-30}|"; classificacaoFinal.AppendLine() .AppendFormat(Culture, formatString, "Posição Chegada", "Código Piloto", "Nome Piloto", "Qtde Voltas Completadas", "Tempo Total de Prova", "Tempo de Chegada Após Vencedor") .AppendLine(); String primeiraLinha = CriarLinhaFormatadoraColunasTabelas(classificacaoFinal); classificacaoFinal.Insert(0, primeiraLinha); classificacaoFinal.Append(primeiraLinha).AppendLine(); TimeSpan tempoChegadaVencedor = pPosicaoFinal.FirstOrDefault().Value.HoraUltimaVolta; int count = 1; // constrói relatorio da classificação final de cada piloto pPosicaoFinal.ToList().ForEach(x => { int codigoPiloto = x.Key; string nomePiloto = x.Value.Piloto.NomePiloto; int qtdVoltas = x.Value.NumeroDeVoltasTotais; string tempoTotal = x.Value.TempoTotalCorrida.ToString(@"hh\:mm\:ss\:fff"); TimeSpan horaChegada = x.Value.HoraUltimaVolta; string diferencaToVencedor = (tempoChegadaVencedor.CompareTo(horaChegada) == 0) ? "(Não se Aplica)" : TimeSpanUtils.OperarTimeSpans(horaChegada, tempoChegadaVencedor, ETimeSpanOperacao.Subtracao).ToString(@"hh\:mm\:ss\:fff"); classificacaoFinal.AppendFormat(Culture, formatString, count++, codigoPiloto.ToString("D3"), nomePiloto, qtdVoltas, tempoTotal, diferencaToVencedor).AppendLine(); }); RelatorioFinal.Append("[ RESULTADO FINAL DA CORRIDA (CLASSIFICAÇÃO) E DIFERENÇA DE TEMPO DE CHEGADA DE CADA PILOTO PARA O VENCEDOR ]").AppendLine().AppendLine(); RelatorioFinal.Append(classificacaoFinal.ToString()); }
// função que calcula e faz chamadas para métodos que ajudarão a construir o relatório final public string CalcularResultadoCorrida(List <IVoltaCorrida> pVoltas) { // Dicionário que conterá dados relevantes de cada piloto ao final da corrida var dDadosPilotosCorrida = new Dictionary <int, DadosCorridaPiloto>(); // agrupa voltas por cada piloto var voltasGroupedByPiloto = pVoltas.GroupBy(x => x.Piloto.Codigo); // para cada piloto, itere sobre suas voltas foreach (var voltaG in voltasGroupedByPiloto) { var voltasPiloto = voltaG.Select(volta => volta); var somadorVelocidades = 0.0f; var ultimaVolta = voltasPiloto.Last(); //para cada volta do piloto atual foreach (var volta in voltasPiloto) { if (!dDadosPilotosCorrida.ContainsKey(voltaG.Key)) { somadorVelocidades += volta.VelocidadeMediaVolta; var dadosCorrida = new DadosCorridaPiloto(volta.HoraVolta, volta.NumeroVolta, volta.TempoVolta, volta.VelocidadeMediaVolta, volta.Piloto); dDadosPilotosCorrida.Add(voltaG.Key, dadosCorrida); } else { //se o piloto já esta no hashmap dados_pilotos_final_da_corrida, atualize seus dados// DadosCorridaPiloto dadosPiloto = dDadosPilotosCorrida[voltaG.Key]; //atualiza hora da última volta dadosPiloto.HoraUltimaVolta = volta.HoraVolta; //atualiza número da volta dadosPiloto.NumeroDeVoltasTotais = volta.NumeroVolta; //atualiza velocidadeTotal dadosPiloto.VelocidadeTotalCorrida = dadosPiloto.VelocidadeTotalCorrida + volta.VelocidadeMediaVolta; //atualiza tempo total durante a corrida dadosPiloto.TempoTotalCorrida = TimeSpanUtils.OperarTimeSpans(dadosPiloto.TempoTotalCorrida, volta.TempoVolta, ETimeSpanOperacao.Adicao); //se tempo da volta atual for melhor (menor) que o anterior, atualize este valor if (volta.TempoVolta < dadosPiloto.MelhorVolta) { dadosPiloto.MelhorVolta = volta.TempoVolta; } // variável que armazena a soma das velocidades de cada volta do piloto atual somadorVelocidades += volta.VelocidadeMediaVolta; // se for a última volta do piloto atual calcule sua Velocidade Média if (volta.Equals(ultimaVolta)) { float velocidadeMedia = somadorVelocidades / voltasPiloto.Count(); dadosPiloto.VelocidadeMediaCorrida = velocidadeMedia; somadorVelocidades = 0.0F; // reseta somadorVelocidades } //atualiza dados do piloto atual no dicionário dDadosPilotosCorrida dDadosPilotosCorrida[voltaG.Key] = dadosPiloto; } } } //Dicionário com classificação final dos pilotos Dictionary <int, DadosCorridaPiloto> posicaoFinal = ComputarPosicaoFinalDosPilotos(dDadosPilotosCorrida); //gera relatório da classificação final da corrida CalcularClassificacaoFinalPilotos(posicaoFinal); //gera relatório da melhor volta de cada piloto na corrida CalcularMelhorVoltaDeCadaPiloto(dDadosPilotosCorrida); //gera relatório da melhor volta da corrida CalcularMelhorVoltaDaCorrida(dDadosPilotosCorrida); //gera relatório da velocidade média de cada piloto na corrida CalcularVelocidadeMediaDeCadaPiloto(dDadosPilotosCorrida); return(RelatorioFinal.ToString()); }
/// <summary> /// Get information about mutiple videos. /// </summary> /// <param name="ids">Videos to get information for.</param> public List <Database.Types.Video> Bulk(List <string> ids) { try { // https://developers.google.com/youtube/v3/docs/videos/list if (ids.Count == 0) { return(null); } List <(int chunkID, List <string> videoIDs)> videoIDChunks = new List <(int chunkID, List <string> videoIDs)>(); List <Database.Types.Video> videosReturn = new List <Database.Types.Video>(); int chunkNumber = 1; SplitIntoChunksLoop: if (ids.Count > 0) { if ((ids.Count > 50) || (ids.Count == 50)) { videoIDChunks.Add((chunkNumber, ids.Take(50).ToList())); ids.RemoveRange(0, 50); } else { videoIDChunks.Add((chunkNumber, ids.Take(ids.Count).ToList())); ids.RemoveRange(0, ids.Count); } chunkNumber++; goto SplitIntoChunksLoop; } LoggingManager.Log.Info($"Video chunk processing finished with {videoIDChunks.Count} total chunks."); foreach ((int chunkID, List <string> videoIDs) in videoIDChunks) { API.VideosResource.ListRequest videoSearch = APIService.Videos.List("id,snippet,contentDetails"); videoSearch.Id = string.Join(",", videoIDs); videoSearch.MaxResults = videoIDs.Count; videoSearch.PrettyPrint = false; API.Data.VideoListResponse response = videoSearch.Execute(); IList <API.Data.Video> videos = response.Items; foreach (API.Data.Video video in videos) { Database.Types.Video videoInfo = new Database.Types.Video { ID = video.Id, ChannelID = video.Snippet.ChannelId, Title = video.Snippet.Title, Description = video.Snippet.Description, Duration = TimeSpanUtils.ConvertDuration(video.ContentDetails.Duration), Posted = DateTime.Parse(video.Snippet.PublishedAt), ThumbnailURL = GetBestThumbnail(video.Snippet.Thumbnails), WatchStatus = WatchStatus.Unwatched }; videosReturn.Add(videoInfo); LoggingManager.Log.Info($"Chunk {chunkID}: Information processed for '{videoInfo.ID}' posted by '{videoInfo.ChannelID}'."); } } return(videosReturn); } catch (Exception ex) { LoggingManager.Log.Error(ex, $"Failed to get information for '{string.Join(",", ids)}'."); return(null); } }
private void btnStart_Click(object sender, EventArgs e) { if (IsRunning) { return; } IsRunning = true; CancellationTokenSource = new CancellationTokenSource(); var options = new TransferAgentOptions { UploadChunkSizeInBytes = 1 * 1024 * 1024, }; string accessKey = txtAccessKey.Text.Trim(); string secretKey = txtSecretKey.Text.Trim(); string bucketName = txtBucketName.Text.Trim(); BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey); string localFilePath = txtFilePath.Text; bool fileInformed = !string.IsNullOrEmpty(localFilePath); bool fileExists = fileInformed && FileManager.FileExists(localFilePath); if (!fileInformed || !fileExists) { string message = ""; if (!fileInformed) { message = "You have to inform a file for upload"; } else if (!fileExists) { message = string.Format("The informed file does not exist: {0}", localFilePath); } MessageBox.Show(message, "Oops!", MessageBoxButtons.OK, MessageBoxIcon.Error); IsRunning = false; return; } #if true string remoteFilePath = typeof(UploadPerfTestControl).Name + ".DELETE_ME"; #else S3PathBuilder pathBuilder = new S3PathBuilder(); string remoteFilePath = pathBuilder.BuildRemotePath(localFilePath); #endif long fileSize = FileManager.UnsafeGetFileSize(localFilePath); BlockPerfStats stats = new BlockPerfStats(); S3TransferAgent xferAgent = new S3TransferAgent(options, credentials, bucketName, CancellationTokenSource.Token); xferAgent.UploadFileStarted += (object sender1, TransferFileProgressArgs e1) => { stats.Begin(); }; xferAgent.UploadFileCanceled += (object sender1, TransferFileProgressArgs e1) => { stats.End(); string message = "Canceled file upload"; MessageBox.Show(message, "Transfer canceled", MessageBoxButtons.OK, MessageBoxIcon.Information); }; xferAgent.UploadFileFailed += (object sender1, TransferFileProgressArgs e1) => { stats.End(); string message = string.Format("Failed to upload file: {0}\n{1}", e1.Exception.GetType().Name, e1.Exception.Message); MessageBox.Show(message, "Transfer failed", MessageBoxButtons.OK, MessageBoxIcon.Error); }; xferAgent.UploadFileCompleted += (object sender1, TransferFileProgressArgs e1) => { stats.End(); string message = string.Format( "Took {0} to upload {1}", TimeSpanUtils.GetReadableTimespan(stats.Duration), FileSizeUtils.FileSizeToString(fileSize) ); MessageBox.Show(message, "Transfer completed", MessageBoxButtons.OK, MessageBoxIcon.Information); }; //xferAgent.UploadFileProgress += (object sender1, TransferFileProgressArgs e1) => //{ // // ... //}; xferAgent.UploadFile(localFilePath, remoteFilePath, null); IsRunning = false; }