elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Página de elhacker.net en Google+ Google+


  Mostrar Mensajes
Páginas: 1 [2] 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ... 1002
11  Foros Generales / Foro Libre / Re: "El Día de Randomize" en: 24 Julio 2017, 21:54
Si hombre, no hay dia del moderador, y vamos a hacer el día de Randomize...

Aquí celebraciones pa tos, o nanai.
12  Foros Generales / Foro Libre / Re: (Encuesta) ¿Que uso le dais al foro? en: 24 Julio 2017, 01:13
Mira, Eleкtro, a mí lo que más daño me ha hecho en ésta vida es que me llamaran "inteligente", ¿OK?

¿Pero que padezca de "extroversia"?

Tendré que hablar con alguien que sepa lo que es para ver como me curo  :-\

Pues inteligente (sin las comillas) eres un rato, ¡demasiado diría yo!... y la introversia (o introvertismo, de introversión, como puñetas se diga) eso si que tú no sabes lo que es. ;)



ahora he decidido "tecnificarme" o sea, leer sólo temas técnicos

Di que sí, Consti. Mira, aquí tienes un tema muy "tecnicista" para que estudies un poco más en profundidad sobre las facetas del buen informático...



Creo que deberiamos aprovechar este tema del compañero @RevolucionVegana para publicar una nueva encuestra sobre cual es la postura favorita de los foreros informáticos... . . . en la silla, claro está.  :xD
13  Foros Generales / Foro Libre / Re: Qué canción estás escuchando ahora ? en: 24 Julio 2017, 01:07
Touch Me Now de Samantha Fox

Ese tema ya lo publiqué yo... ¡COPIONA!. Cúrrate tu propio material lésbico xD. :P

La letra de la canción  This is the night .......Esta es la noche
                                  Touch Me now......Tócame ahora
                                I want your body ....:Quiero tu cuerpo

Es muy erótica si se lo dice una chica a un chico, pero no una chica a otra chica .....es sólo mi opinión, pero quería expresarla

Pero... ¿tu sabes que no se puede rechazar la comida sin haberlo probado antes, verdad?. :rolleyes:

PD: De todas formas opino algo parecido a lo que tú, pero mejor me voy a callar... que no es momento ni lugar para hablar sobre enfermedades anomalías aceptadas e incurables del ser humano.



Volviendo al tema, comparto una de mis canciones y rumbas favoritas con las que se me pone la piel de gallina... siempre.

Estopa - Luna Lunera


14  Foros Generales / Foro Libre / Re: EEUU pide a sus ciudadanos en Corea del Norte que salgan del país inmediatamente en: 23 Julio 2017, 23:15
A mi el tema este de yanquis vs. "amarillos"... me aburre a más no poder. Siempre están igual, y ya cansan. ¿No os aburris de estar leyendo cada 2x3 lo mismo sobre este asunto?...

Si realmente uno de los dos tuviese intención de atacar al otro, entonces YA LO HABRÍAN HECHO. Aquí nadie va a invadir a nadie, solo buscan polémica entre sus ciudadanos y los del resto del mundo para hacerse de notar ellos, ellos junto a su egocentrismo, abaricia, codicia de poder, siempre midiéndose "la chorra" el uno al otro como si fuesen dos animales salvajes en celo compitiendo por una hembra; y que se especule de ellos, cuanto más, mejor, para que siempre sigan estando estas dos "potencias" en el punto de mira del objetivo de la prensa especializada, en cada conversación que tengamos con nuestros seres conocidos, conversación a cada cual más absurda con ridículos planteamientos sobre una posible y patética guerra de la que se lleva hablando mucho, pero oye, que jamás llega... aunque siempre está ahí la "posibilidad", o al menos eso dicen, en el primer puesto de las noticias, vendiendo miedo y morbo, justo lo que el ser humano quiere, ser manipulado subliminálmente con basura y especulación putrefacta para complacer a sus pocas neuronas, si, cremita de la buena para aliviar el cerebro más atrofiado, Corea del Norte y EEUU siempre al filo de un eterno inicio de una supuesta guerra... esto es mierd* en estado puro, lo que le da de comer a la prensa amarillista, basura, BASURA!, BA-SU-RA !!.

En fin. Lo siento por mi negatividad, pero es lo que pienso.

Saludos!
15  Foros Generales / Foro Libre / Re: (Encuesta) ¿Que uso le dais al foro? en: 23 Julio 2017, 22:59
Pues yo ejerzo un poco de todas las opciones, de la A a la Z. Y en especial:

G- Otras cosas (a ser posible poner que cosas)

Para moderar el compor... la... "extroversia" de Randomize. :P

PD: Y que nadie me venga otra vez con aquello de "se acepta pulpo como animal de compañia" -.-



Si algún moderador quiere cerrarme el tema y hacerla él por mi encantado xD pero no es plan de ir molestando, aunque creo que sería interesante para ellos ver los resultados de la encuesta :P

No sé, yo lo veo un poco faltarle el respeto al autor (es decir, tú). Pero si realmente quieres que hagan una encuesta y cierren tu tema, entonces puedes enviar una petición por mensaje privado... o esperar a que otro mod. haga uso de su juicio personal y su criterio sea distinto al mio.

Saludos!
16  Programación / .NET / Re: C# - Hackear una contrasena de un servidor en: 23 Julio 2017, 22:30
No se si lo puedo llamar inyeccion de codigo pero lo hare hasta que ustedes me digan que es incorrecto llamarlo asi a esto.

Lo que estás haciendo se denomina IPC (Inter-Process Communication). Inyección de código... no lo es xD.



Si te lias con las comillas y con el operador de concatenación de C#, recuerda que siempre tienes a tu disposición una herramienta muy útil de formato... precisamente para evitar la escritura excesiva (y horriblemente ininteligible cuando se usa en exceso) de comillas y de +++++. Me estoy refiriendo a la función String.Fromat():

Código
  1. string str = string.Format("/login {0}", this.contrasena)

Saludos
17  Programación / .NET / Re: [C#] Mover archivos de windows || Isolated Storage en: 23 Julio 2017, 22:06
Hasta a mi me podria servir esto en futuro.....

Ojalá, aunque está muy recortado. Es versión "slim". :xD

Gracias por tu aporte!!!

Gracias a ti también por colaborar con tu código, aunque al parecer no te funciona, jeje.

En un principio no entiendo muy bien por qué buscas un archivo llamado "datos.txt" y que contenga lineas con el texto "Origen" y "Destino" dentro de ese archivo, pero bueno, creo que das a entender un formato similar a esto:

Datos.txt
Código:
Origen: C:\CarpetaOrigen1
Destino: C:\CarpetaDestino1

Origen: C:\CarpetaOrigen2
Destino: C:\CarpetaDestino2

Origen: C:\CarpetaOrigen3
Destino: C:\CarpetaDestino3
etc...

Pero luego haces una llamada a File.Move(), que además lo tienes colocado FUERA del ciclo, aparte, creo que es evidente por que no funciona eso de mover una carpeta como si fuese un archivo xD (en su lugar puedes usar el método Directory.Move(), que además puede mover archivos también).

Teniendo un archivo de texto con el formato de arriba, quizás lo que realmente querías hacer es algo así:

Código
  1. DirectoryInfo srcDir = null;
  2. DirectoryInfo dstDir = null;
  3.  
  4. foreach (string line in File.ReadLines(@".\datos.txt", Encoding.Default)) {
  5.    if (line.StartsWith("origen", StringComparison.OrdinalIgnoreCase)) {
  6.        srcDir = new DirectoryInfo(line.Substring(line.IndexOf(' ')));
  7.    }
  8.  
  9.    if (line.StartsWith("destino", StringComparison.OrdinalIgnoreCase)) {
  10.        dstDir = new DirectoryInfo(line.Substring(line.IndexOf(' ')));
  11.    }
  12.  
  13.    if ((srcDir != null) && (dstDir != null)) {
  14.        try {
  15.            if (!srcDir.Exists) {
  16.                throw new DirectoryNotFoundException(srcDir.FullName);
  17.            }
  18.  
  19.            if (!dstDir.Exists) {
  20.                dstDir.Create();
  21.            }
  22.            srcDir.MoveTo(Path.Combine(dstDir.FullName, srcDir.Name));
  23.  
  24.        } catch (Exception ex) {
  25.            throw;
  26.  
  27.        } finally {
  28.            srcDir = null;
  29.            dstDir = null;
  30.  
  31.        }
  32.  
  33.    }
  34.  
  35. }

Saludos!
18  Programación / .NET / Re: [C#] Mover archivos de windows || Isolated Storage en: 23 Julio 2017, 20:38
Yo crei que solo se trataba de mover archivos de una carpeta a otra.

No sé, espero no haberme equivocado yo... por que de lo contrario estoy escribiendo mucho para nada xD. Lo que yo he interpretado es que el usuario pretende subir un archivo local, a una carpeta llamada "desktop" en su cuenta de Google Drive, y sobreescribir ese archivo existente por el archivo local. Como ya digo, espero no haberme equivocado yo xD.



( Me tomo la libertad de hacer doble post, por que el código de este comentario no cabe en el de arriba. )

No suelo entregarle el trabajo hecho a nadie, sino las herramientas para hacerlo, pero entiendo que hablar de APIs de terceros (y más siendo tan "completas" o extensas como las de Google) es sinónimo de pereza y dificultad... basicamente por que hay que aprender muy bien como funciona "internamente" para poder hacer algo con esa API.

Bueno, pues voy a intentar ayudarte un poco más en ese aspecto compartiendo contigo (y con los demás a los que les pueda resultar útil) un código que he extraido de mi framework comercial ElektroKit, que si a alguien le interesa... lo puede encontrar en mi firma de usuario.
El código original lo he recortado mucho solamente para dejar los miembros/funcionalidades que tú necesitarías para reproducir esa "macro", es decir la funcionalidad de autorización, la de identificar el archivo a sobreescribir, y la de sobreescribirlo.

EDITO: Lo he tenido que recortar muchísimo más de lo que esperaba para que quepa. Maldito límite de 30.000 caracteres XD.

Bueno, aquí lo tienes:

Código
  1. #Region " Google Drive Scopes "
  2.  
  3. Namespace Google.Drive.Enums
  4.  
  5.    ''' <summary>
  6.    ''' Specifies the OAuthv2 scopes for use with the Google Drive API.
  7.    ''' </summary>
  8.    <Flags>
  9.    Public Enum DriveScopes As Integer
  10.  
  11.        ''' <summary>
  12.        ''' View and manage the files in your Google Drive.
  13.        ''' </summary>
  14.        Full = 2
  15.  
  16.        ''' <summary>
  17.        ''' View and manage its own configuration data in your Google Drive.
  18.        ''' </summary>
  19.        ApplicationData = 4
  20.  
  21.        ''' <summary>
  22.        ''' View and manage Google Drive files and folders that you have opened or created with this application.
  23.        ''' </summary>
  24.        Files = 8
  25.  
  26.        ''' <summary>
  27.        ''' View and manage metadata of files in your Google Drive.
  28.        ''' </summary>
  29.        Metadata = 16
  30.  
  31.        ''' <summary>
  32.        ''' Modify your Google Apps Script scripts' behavior.
  33.        ''' </summary>
  34.        Scripts = 32
  35.  
  36.        ''' <summary>
  37.        ''' View the files in your Google Drive.
  38.        ''' </summary>
  39.        [ReadOnly] = 64
  40.  
  41.        ''' <summary>
  42.        ''' View metadata for files in your Google Drive.
  43.        ''' </summary>
  44.        MetadataReadonly = 128
  45.  
  46.        ''' <summary>
  47.        ''' View the photos, videos and albums in your Google Photos.
  48.        ''' </summary>
  49.        PhotosReadonly = 256
  50.  
  51.    End Enum
  52.  
  53. End Namespace
  54.  
  55. #End Region

+

Código
  1. #Region " Option Statements "
  2.  
  3. Option Strict On
  4. Option Explicit On
  5. Option Infer Off
  6.  
  7. #End Region
  8.  
  9. #Region " Imports "
  10.  
  11. Imports Google.Apis.Auth.OAuth2
  12. Imports Google.Apis.Drive.v3
  13. Imports Google.Apis.Drive.v3.Data
  14. Imports Google.Apis.Services
  15. Imports Google.Apis.Upload
  16. Imports Google.Apis.Util.Store
  17.  
  18. Imports Google.Drive.Enums
  19.  
  20. #End Region
  21.  
  22. #Region " Google Drive Client "
  23.  
  24. Namespace Google.Drive.Types
  25.  
  26.    ''' ----------------------------------------------------------------------------------------------------
  27.    ''' <summary>
  28.    ''' A client for Google Drive service.
  29.    ''' </summary>
  30.    ''' ----------------------------------------------------------------------------------------------------
  31.    Public NotInheritable Class DriveClient : Implements IDisposable
  32.  
  33. #Region " Private Fields "
  34.  
  35.        Private client As DriveService
  36.        Private credential As UserCredential
  37.        Private ReadOnly authExceptionMessage As String =
  38.            "The user has not yet authorized the usage of this application.
  39.             Call 'DriveClient.Authorize()' or 'DriveClient.AuthorizeAsync()' methods."
  40.        Private scopeDict As New Dictionary(Of DriveScopes, String)(StringComparison.Ordinal) From
  41.        {
  42.            {DriveScopes.Full, DriveService.Scope.Drive},
  43.            {DriveScopes.ApplicationData, DriveService.Scope.DriveAppdata},
  44.            {DriveScopes.Files, DriveService.Scope.DriveFile},
  45.            {DriveScopes.Metadata, DriveService.Scope.DriveMetadata},
  46.            {DriveScopes.MetadataReadonly, DriveService.Scope.DriveMetadataReadonly},
  47.            {DriveScopes.PhotosReadonly, DriveService.Scope.DrivePhotosReadonly},
  48.            {DriveScopes.ReadOnly, DriveService.Scope.DriveReadonly},
  49.            {DriveScopes.Scripts, DriveService.Scope.DriveScripts}
  50.        }
  51.  
  52. #End Region
  53.  
  54. #Region " Properties "
  55.  
  56.        ''' <summary>
  57.        ''' Gets the client credentials.
  58.        ''' </summary>
  59.        Public ReadOnly Property Secrets As ClientSecrets
  60.  
  61.        ''' <summary>
  62.        ''' Gets the mail address to authorize Drive service. (e.g: "mail@gmail.com")
  63.        ''' </summary>
  64.        Public ReadOnly Property MailAddress As String
  65.  
  66.        ''' <summary>
  67.        ''' Gets the current Drive OAuthv2 scopes.
  68.        ''' </summary>
  69.        Public ReadOnly Property Scopes As DriveScopes
  70.  
  71.        ''' <summary>
  72.        ''' Gets a value that determines whether Google Drive API authorization was done.
  73.        ''' </summary>
  74.        Public ReadOnly Property IsAuthorized As Boolean
  75.            Get
  76.                Return isAuthorizedB
  77.            End Get
  78.        End Property
  79.        Private isAuthorizedB As Boolean = False
  80.  
  81. #End Region
  82.  
  83. #Region " Constructors "
  84.  
  85.        Private Sub New()
  86.        End Sub
  87.  
  88.        ''' <param name="apiFile">
  89.        ''' The <c>client_secrets.json</c> file generated by Drive API console that contains the OAuthv2 login data
  90.        ''' such as the client id, client secret, and redirection URI.
  91.        ''' </param>
  92.        ''' <param name="mailAddress">
  93.        ''' The mail address to authorize Drive service. (e.g: "mail@gmail.com")
  94.        ''' </param>
  95.        ''' <param name="scopes">
  96.        ''' The Drive OAuthv2 scope.
  97.        ''' </param>
  98.        Public Sub New(apiFile As FileInfo, mailAddress As String, scopes As DriveScopes)
  99.            Me.MailAddress = mailAddress
  100.            Me.Scopes = scopes
  101.            Using sr As FileStream = apiFile.OpenRead()
  102.                Me.Secrets = GoogleClientSecrets.Load(sr).Secrets
  103.            End Using
  104.        End Sub
  105.  
  106. #End Region
  107.  
  108. #Region " Public Methods "
  109.  
  110. #Region " Authorization "
  111.  
  112.        ''' <summary>
  113.        ''' Authorizes this instance to use Google Drive API services.
  114.        ''' </summary>
  115.        ''' <example>
  116.        ''' <code>
  117.        ''' Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  118.        ''' Dim credential As UserCredential = client.Authorize()
  119.        ''' </code>
  120.        ''' </example>
  121.        Public Function Authorize() As UserCredential
  122.            Dim t As Task(Of UserCredential) = Task.Run(AddressOf Me.AuthorizeAsync)
  123.            t.Wait(Timeout.Infinite)
  124.            Return t.Result
  125.        End Function
  126.  
  127.        ''' <summary>
  128.        ''' Authorizes this instance to use Google Drive API services.
  129.        ''' </summary>
  130.        ''' <example>
  131.        ''' <code>
  132.        ''' Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  133.        ''' Dim credential As UserCredential = Await client.AuthorizeAsync()
  134.        ''' </code>
  135.        ''' </example>
  136.        Public Async Function AuthorizeAsync() As Task(Of UserCredential)
  137.            Dim scopeUrls As String() = GetScopeUrls(Scopes)
  138.  
  139.            Me.credential =
  140.                 Await GoogleWebAuthorizationBroker.AuthorizeAsync(Secrets,
  141.                                                                   scopeUrls.ToArray(),
  142.                                                                   MailAddress,
  143.                                                                   CancellationToken.None,
  144.                                                                   New FileDataStore("UNET", fullPath:=False))
  145.  
  146.            Me.client = New DriveService(New BaseClientService.Initializer() With {
  147.                                         .HttpClientInitializer = Me.credential,
  148.                                         .ApplicationName = "UNET" ', .ApiKey = ""
  149.            })
  150.  
  151.            isAuthorizedB = True
  152.            Return Me.credential
  153.        End Function
  154.  
  155. #End Region
  156.  
  157. #Region " Get Files "
  158.  
  159.        ''' <summary>
  160.        ''' Gets all the files stored in the current user account.
  161.        ''' </summary>
  162.        ''' <example>
  163.        ''' <code>
  164.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  165.        '''     Dim credential As UserCredential = client.Authorize()
  166.        '''     Dim files As List(Of File) = client.GetFiles()
  167.        '''
  168.        '''     For Each file As File In files
  169.        '''         Dim sb As New StringBuilder
  170.        '''         With sb
  171.        '''             .AppendLine(String.Format("Id: {0}", file.Id))
  172.        '''             .AppendLine(String.Format("Owned By Me?: {0}", file.OwnedByMe))
  173.        '''             .AppendLine(String.Format("Name: {0}", file.Name))
  174.        '''         End With
  175.        '''         Console.WriteLine(sb.ToString)
  176.        '''     Next file
  177.        ''' </code>
  178.        ''' </example>
  179.        Public Function GetFiles() As List(Of File)
  180.            If Not (isAuthorizedB) Then
  181.                Throw New InvalidOperationException(authExceptionMessage)
  182.  
  183.            Else
  184.                Dim t As Task(Of List(Of File)) = Task.Run(AddressOf GetFilesAsync)
  185.                t.Wait(Timeout.Infinite)
  186.                Return t.Result
  187.  
  188.            End If
  189.        End Function
  190.  
  191.        ''' <summary>
  192.        ''' Asynchronously gets all the files stored in the current user account.
  193.        ''' </summary>
  194.        ''' <example>
  195.        ''' <code>
  196.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  197.        '''     Dim credential As UserCredential = Await client.AuthorizeAsync()
  198.        '''     Dim files As List(Of File) = Await client.GetFilesAsync()
  199.        '''
  200.        '''     For Each file As File In files
  201.        '''         Dim sb As New StringBuilder
  202.        '''         With sb
  203.        '''             .AppendLine(String.Format("Id: {0}", file.Id))
  204.        '''             .AppendLine(String.Format("Owned By Me?: {0}", file.OwnedByMe))
  205.        '''             .AppendLine(String.Format("Name: {0}", file.Name))
  206.        '''         End With
  207.        '''         Console.WriteLine(sb.ToString)
  208.        '''     Next file
  209.        ''' </code>
  210.        ''' </example>
  211.        Public Async Function GetFilesAsync() As Task(Of List(Of File))
  212.  
  213.            If Not (isAuthorizedB) Then
  214.                Throw New InvalidOperationException(authExceptionMessage)
  215.  
  216.            Else
  217.                Dim request As FilesResource.ListRequest = Me.client.Files.List()
  218.                With request
  219.                    .PageSize = 100
  220.                    .IncludeTeamDriveItems = False
  221.                    .SupportsTeamDrives = False
  222.                    .Fields = "nextPageToken, files"
  223.                    .Q = "not mimeType contains 'folder'"
  224.                End With
  225.  
  226.                Dim response As FileList = Await request.ExecuteAsync()
  227.  
  228.                Dim files As New List(Of File)
  229.                Do While True
  230.  
  231.                    For Each file As File In response.Files
  232.                        Dim getRequest As FilesResource.GetRequest = Me.client.Files.Get(file.Id)
  233.                        With getRequest
  234.                            .SupportsTeamDrives = False
  235.                            .Fields = "*"
  236.                        End With
  237.  
  238.                        Dim getResponse As File = Await getRequest.ExecuteAsync()
  239.                        getRequest.AcknowledgeAbuse = True
  240.                        files.Add(getResponse)
  241.                    Next file
  242.  
  243.                    If Not String.IsNullOrEmpty(response.NextPageToken) Then
  244.                        request.PageToken = response.NextPageToken
  245.                        response = Await request.ExecuteAsync()
  246.                    Else
  247.                        Exit Do
  248.                    End If
  249.  
  250.                Loop
  251.  
  252.                Return files
  253.  
  254.            End If
  255.  
  256.        End Function
  257.  
  258.        ''' <summary>
  259.        ''' Asynchronously gets the files stored in the current user account that matches the specified search criteria.
  260.        ''' </summary>
  261.        ''' <example>
  262.        ''' <code>
  263.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  264.        '''     Dim credential As UserCredential = Await client.AuthorizeAsync()
  265.        '''     Dim predicate As Func(Of File, Boolean) =
  266.        '''         Function(f As File) f.Name.Equals("My Folder Name", StringComparison.OrdinalIgnoreCase)
  267.        '''     Dim files As List(Of File) = Await client.GetFilesAsync(predicate)
  268.        '''
  269.        '''     For Each file As File In files
  270.        '''         Dim sb As New StringBuilder
  271.        '''         With sb
  272.        '''             .AppendLine(String.Format("Id: {0}", file.Id))
  273.        '''             .AppendLine(String.Format("Name: {0}", file.Name))
  274.        '''         End With
  275.        '''         Console.WriteLine(sb.ToString)
  276.        '''     Next file
  277.        ''' </code>
  278.        ''' </example>
  279.        Public Async Function GetFilesAsync(predicate As Func(Of File, Boolean)) As Task(Of List(Of File))
  280.            Dim folders As List(Of File) = Await GetFilesAsync()
  281.            Return folders.Where(predicate).ToList()
  282.        End Function
  283.  
  284.        ''' <summary>
  285.        ''' Gets a file stored in the current user account that matches the specified file id.
  286.        ''' </summary>
  287.        ''' <example>
  288.        ''' <code>
  289.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  290.        '''     Dim credential As UserCredential = client.Authorize()
  291.        '''     Dim file As File) = client.GetFileById(" File Id. ")
  292.        '''
  293.        '''     Dim sb As New StringBuilder
  294.        '''     With sb
  295.        '''          .AppendLine(String.Format("Id: {0}", file.Id))
  296.        '''          .AppendLine(String.Format("Owned By Me?: {0}", file.OwnedByMe))
  297.        '''          .AppendLine(String.Format("Name: {0}", file.Name))
  298.        '''     End With
  299.        '''     Console.WriteLine(sb.ToString)
  300.        ''' </code>
  301.        ''' </example>
  302.        Public Function GetFileById(id As String) As File
  303.            If Not (isAuthorizedB) Then
  304.                Throw New InvalidOperationException(authExceptionMessage)
  305.  
  306.            Else
  307.                Dim t As Task(Of File) = Task.Run(Function() GetFileByIdAsync(id))
  308.                t.Wait(Timeout.Infinite)
  309.                Return t.Result
  310.  
  311.            End If
  312.        End Function
  313.  
  314.        ''' <summary>
  315.        ''' Asynchronously gets a file stored in the current user account that matches the specified file id.
  316.        ''' </summary>
  317.        ''' <example>
  318.        ''' <code>
  319.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  320.        '''     Dim credential As UserCredential = Await client.AuthorizeAsync()
  321.        '''     Dim file As File) = Await client.GetFileByIdAsync(" File Id. ")
  322.        '''
  323.        '''     Dim sb As New StringBuilder
  324.        '''     With sb
  325.        '''          .AppendLine(String.Format("Id: {0}", file.Id))
  326.        '''          .AppendLine(String.Format("Owned By Me?: {0}", file.OwnedByMe))
  327.        '''          .AppendLine(String.Format("Name: {0}", file.Name))
  328.        '''     End With
  329.        '''     Console.WriteLine(sb.ToString)
  330.        ''' </code>
  331.        ''' </example>
  332.        Public Async Function GetFileByIdAsync(id As String) As Task(Of File)
  333.            If Not (isAuthorizedB) Then
  334.                Throw New InvalidOperationException(authExceptionMessage)
  335.  
  336.            Else
  337.                Dim predicate As Func(Of File, Boolean) =
  338.                      Function(f As File) f.Id.Equals(id, StringComparison.OrdinalIgnoreCase)
  339.  
  340.                Dim result As List(Of File) = Await Task.Run(Function() GetFilesAsync(predicate))
  341.                Return result.DefaultIfEmpty(Nothing).SingleOrDefault()
  342.  
  343.            End If
  344.        End Function
  345.  
  346. #End Region
  347.  
  348. #Region " Update (replace) File "
  349.  
  350.        ''' <summary>
  351.        ''' Updates (replaces) a existing file in the specified folder.
  352.        ''' </summary>
  353.        ''' <example>
  354.        ''' <code>
  355.        ''' Private Sub UpdateFile()
  356.        '''
  357.        '''    Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  358.        '''    Dim credential As UserCredential = client.Authorize()
  359.        '''
  360.        '''    Dim srcFile As New FileInfo("C:\File.ext")
  361.        '''    Dim dstFile As File = client.GetFilesByName("File to update.ext").Single()
  362.        '''
  363.        '''    Dim result As KeyValuePair(Of Upload.ResumableUpload, File) =
  364.        '''        client.UpdateFile(srcFile, dstFile)
  365.        '''        
  366.        '''    Dim upload As ResumableUpload = result.Key
  367.        '''    
  368.        '''    Select Case upload.GetProgress().Status
  369.        '''    
  370.        '''        Case Upload.UploadStatus.Failed
  371.        '''            Console.WriteLine("Upload Failed.")
  372.        '''            ' ToDo: Retry/Resume Upload?:
  373.        '''            ' upload.Upload()
  374.        '''            ' upload.Resume()
  375.        '''            
  376.        '''        Case Upload.UploadStatus.Completed
  377.        '''            Dim dstFile As ResumableUpload = result.Value
  378.        '''            Dim sb As New StringBuilder
  379.        '''            With sb
  380.        '''                .AppendLine(String.Format("Id: {0}", dstFile.Id))
  381.        '''                .AppendLine(String.Format("Name: {0}", dstFile.Name))
  382.        '''            End With
  383.        '''        Console.WriteLine(sb.ToString)
  384.        '''        
  385.        '''    End Select
  386.        '''
  387.        ''' End Sub
  388.        ''' </code>
  389.        ''' </example>
  390.        ''' <param name="srcFile">
  391.        ''' The source file to upload.
  392.        ''' </param>
  393.        ''' <param name="dstFile">
  394.        ''' The metadata of the existing file being updated.
  395.        ''' </param>
  396.        Public Function UpdateFile(srcFile As FileInfo, dstFile As File) As KeyValuePair(Of ResumableUpload, File)
  397.            If Not (isAuthorizedB) Then
  398.                Throw New InvalidOperationException(authExceptionMessage)
  399.  
  400.            Else
  401.                Dim t As Task(Of KeyValuePair(Of ResumableUpload, File)) =
  402.                    Task.Run(Function() Me.UpdateFileAsync(srcFile, dstFile, Nothing, Nothing))
  403.                t.Wait(Timeout.Infinite)
  404.                Return t.Result
  405.  
  406.            End If
  407.        End Function
  408.  
  409.        ''' <summary>
  410.        ''' Updates (replaces) a existing file in the specified folder.
  411.        ''' </summary>
  412.        ''' <example>
  413.        ''' <code>
  414.        ''' Private Sub UpdateFile()
  415.        '''
  416.        '''    Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  417.        '''    Dim credential As UserCredential = client.Authorize()
  418.        '''
  419.        '''    Dim srcFile As New FileInfo("C:\File.ext")
  420.        '''
  421.        '''    Dim result As KeyValuePair(Of Upload.ResumableUpload, File) =
  422.        '''        client.UpdateFile(srcFile, "File Id")
  423.        '''        
  424.        '''    Dim upload As ResumableUpload = result.Key
  425.        '''    
  426.        '''    Select Case upload.GetProgress().Status
  427.        '''    
  428.        '''        Case Upload.UploadStatus.Failed
  429.        '''            Console.WriteLine("Upload Failed.")
  430.        '''            ' ToDo: Retry/Resume Upload?:
  431.        '''            ' upload.Upload()
  432.        '''            ' upload.Resume()
  433.        '''            
  434.        '''        Case Upload.UploadStatus.Completed
  435.        '''            Dim dstFile As ResumableUpload = result.Value
  436.        '''            Dim sb As New StringBuilder
  437.        '''            With sb
  438.        '''                .AppendLine(String.Format("Id: {0}", dstFile.Id))
  439.        '''                .AppendLine(String.Format("Name: {0}", dstFile.Name))
  440.        '''            End With
  441.        '''        Console.WriteLine(sb.ToString)
  442.        '''        
  443.        '''    End Select
  444.        '''
  445.        ''' End Sub
  446.        ''' </code>
  447.        ''' </example>
  448.        ''' <param name="srcFile">
  449.        ''' The source file to upload.
  450.        ''' </param>
  451.        ''' <param name="dstFileId">
  452.        ''' The identifier of the existing file being updated.
  453.        ''' </param>
  454.        Public Function UpdateFile(srcFile As FileInfo, dstFileId As String) As KeyValuePair(Of ResumableUpload, File)
  455.            If Not (isAuthorizedB) Then
  456.                Throw New InvalidOperationException(authExceptionMessage)
  457.  
  458.            Else
  459.                Dim dstFile As File = GetFileById(dstFileId)
  460.                If (dstFile Is Nothing) Then
  461.                    Throw New Exception(String.Format("File not found with the specified Id: {0}", dstFileId))
  462.                End If
  463.  
  464.                Dim t As Task(Of KeyValuePair(Of ResumableUpload, File)) =
  465.                    Task.Run(Function() Me.UpdateFileAsync(srcFile, dstFile, Nothing, Nothing))
  466.                t.Wait(Timeout.Infinite)
  467.                Return t.Result
  468.  
  469.            End If
  470.        End Function
  471.  
  472.        ''' <summary>
  473.        ''' Asynchronously updates (replaces) a existing file in the specified folder.
  474.        ''' </summary>
  475.        ''' <example>
  476.        ''' <code>
  477.        ''' Private Async Sub UpdateFile()
  478.        '''
  479.        '''    Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  480.        '''    Dim credential As UserCredential = Await client.AuthorizeAsync()
  481.        '''
  482.        '''    Dim srcFile As New FileInfo("C:\File.ext")
  483.        '''    Dim dstFile As File = client.GetFilesByName("File to update.ext").Single()
  484.        '''
  485.        '''    Dim result As KeyValuePair(Of Upload.ResumableUpload, File) =
  486.        '''        Await client.UpdateFileAsync(srcFile, dstFile, AddressOf Me.Upload_ProgressChanged, Nothing)
  487.        '''
  488.        '''     Dim sb As New StringBuilder
  489.        '''     With sb
  490.        '''         .AppendLine(String.Format("Id: {0}", result.Value.Id))
  491.        '''         .AppendLine(String.Format("Name: {0}", result.Value.Name))
  492.        '''     End With
  493.        '''     Console.WriteLine(sb.ToString)
  494.        '''
  495.        ''' End Sub
  496.        '''
  497.        ''' Public Sub Upload_ProgressChanged(e As Upload.IUploadProgress)
  498.        '''
  499.        '''     Select Case e.Status
  500.        '''
  501.        '''         Case Upload.UploadStatus.Uploading
  502.        '''             Console.WriteLine("Bytes sent: {0}", e.BytesSent)
  503.        '''
  504.        '''         Case Upload.UploadStatus.Completed
  505.        '''             Console.WriteLine("Upload completed.")
  506.        '''
  507.        '''         Case Upload.UploadStatus.Failed
  508.        '''             Console.WriteLine("Upload failed. Reason: {0}", e.Exception.Message)
  509.        '''
  510.        '''         Case Else
  511.        '''             ' Do Nothing.
  512.        '''
  513.        '''     End Select
  514.        '''
  515.        ''' End Sub
  516.        ''' </code>
  517.        ''' </example>
  518.        ''' <param name="srcFile">
  519.        ''' The source file to upload.
  520.        ''' </param>
  521.        ''' <param name="dstFile">
  522.        ''' The metadata of the existing file being updated.
  523.        ''' </param>
  524.        ''' <param name="progressHandler">
  525.        ''' A event handler that will receive progress changes of the upload operation.
  526.        ''' </param>
  527.        ''' <param name="cancellationToken">
  528.        ''' A cancellation token to cancel the upload operation.
  529.        ''' </param>
  530.        Public Async Function UpdateFileAsync(srcFile As FileInfo,
  531.                                              dstFile As File,
  532.                                              progressHandler As Action(Of IUploadProgress),
  533.                                              cancellationToken As CancellationToken) As Task(Of KeyValuePair(Of ResumableUpload, File))
  534.  
  535.            If Not (isAuthorizedB) Then
  536.                Throw New InvalidOperationException(authExceptionMessage)
  537.  
  538.            Else
  539.                Dim request As FilesResource.UpdateMediaUpload
  540.                Dim progress As IUploadProgress
  541.                Using stream As New FileStream(srcFile.FullName, FileMode.Open, FileAccess.Read, FileShare.Read)
  542.  
  543.                    Dim dstFileTemp As New File() With {
  544.                        .AppProperties = dstFile.AppProperties,
  545.                        .Name = srcFile.Name,
  546.                        .Description = dstFile.Description,
  547.                        .Kind = dstFile.Kind,
  548.                        .Properties = dstFile.Properties,
  549.                        .OriginalFilename = dstFile.OriginalFilename,
  550.                        .Trashed = dstFile.Trashed,
  551.                        .WritersCanShare = dstFile.WritersCanShare
  552.                    }
  553.  
  554.                    request = Me.client.Files.Update(dstFileTemp, dstFile.Id, stream, dstFile.MimeType)
  555.                    With request
  556.                        .AddParents = String.Join(",", dstFile.Parents)
  557.                        .ChunkSize = 262144
  558.                        .SupportsTeamDrives = False
  559.                        .Fields = "*"
  560.                    End With
  561.  
  562.                    AddHandler request.ProgressChanged, progressHandler
  563.                    progress = Await request.UploadAsync(cancellationToken)
  564.                    RemoveHandler request.ProgressChanged, progressHandler
  565.                End Using
  566.  
  567.                Dim response As File = request.ResponseBody
  568.                Return New KeyValuePair(Of ResumableUpload, File)(request, response)
  569.  
  570.            End If
  571.  
  572.        End Function
  573.  
  574.        ''' <summary>
  575.        ''' Asynchronously updates (replaces) a existing file in the specified folder.
  576.        ''' </summary>
  577.        ''' <example>
  578.        ''' <code>
  579.        ''' Private Async Sub UpdateFile()
  580.        '''
  581.        '''    Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  582.        '''    Dim credential As UserCredential = Await client.AuthorizeAsync()
  583.        '''
  584.        '''    Dim srcFile As New FileInfo("C:\File.ext")
  585.        '''
  586.        '''    Dim result As KeyValuePair(Of Upload.ResumableUpload, File) =
  587.        '''        Await client.UpdateFileAsync(srcFile, "File Id", AddressOf Me.Upload_ProgressChanged, Nothing)
  588.        '''
  589.        '''     Dim sb As New StringBuilder
  590.        '''     With sb
  591.        '''         .AppendLine(String.Format("Id: {0}", result.Value.Id))
  592.        '''         .AppendLine(String.Format("Name: {0}", result.Value.Name))
  593.        '''     End With
  594.        '''     Console.WriteLine(sb.ToString)
  595.        '''
  596.        ''' End Sub
  597.        '''
  598.        ''' Public Sub Upload_ProgressChanged(e As Upload.IUploadProgress)
  599.        '''
  600.        '''     Select Case e.Status
  601.        '''
  602.        '''
  603.        '''         Case Upload.UploadStatus.Uploading
  604.        '''             Console.WriteLine("Bytes sent: {0}", e.BytesSent)
  605.        '''
  606.        '''         Case Upload.UploadStatus.Completed
  607.        '''             Console.WriteLine("Upload completed.")
  608.        '''
  609.        '''         Case Upload.UploadStatus.Failed
  610.        '''             Console.WriteLine("Upload failed. Reason: {0}", e.Exception.Message)
  611.        '''
  612.        '''         Case Else
  613.        '''             ' Do Nothing.
  614.        '''
  615.        '''     End Select
  616.        '''
  617.        ''' End Sub
  618.        ''' </code>
  619.        ''' </example>
  620.        ''' <param name="srcFile">
  621.        ''' The source file to upload.
  622.        ''' </param>
  623.        ''' <param name="dstFileId">
  624.        ''' The identifier of the existing file being updated.
  625.        ''' </param>
  626.        ''' <param name="progressHandler">
  627.        ''' A event handler that will receive progress changes of the upload operation.
  628.        ''' </param>
  629.        ''' <param name="cancellationToken">
  630.        ''' A cancellation token to cancel the upload operation.
  631.        ''' </param>
  632.        Public Async Function UpdateFileAsync(srcFile As FileInfo,
  633.                                              dstFileId As String,
  634.                                              progressHandler As Action(Of IUploadProgress),
  635.                                              cancellationToken As CancellationToken) As Task(Of KeyValuePair(Of ResumableUpload, File))
  636.  
  637.            If Not (isAuthorizedB) Then
  638.                Throw New InvalidOperationException(authExceptionMessage)
  639.  
  640.            Else
  641.                Dim dstFile As File = Await GetFileByIdAsync(dstFileId)
  642.                If (dstFile Is Nothing) Then
  643.                    Throw New Exception(String.Format("File not found with the specified Id: {0}", dstFileId))
  644.                End If
  645.  
  646.                Return Await Me.UpdateFileAsync(srcFile, dstFile, progressHandler, cancellationToken)
  647.  
  648.            End If
  649.  
  650.        End Function
  651.  
  652. #End Region
  653.  
  654. #End Region
  655.  
  656. #Region " Private Methods "
  657.  
  658.        Private Function GetScopeUrls(scopes As DriveScopes) As String()
  659.  
  660.            Return (From scope As KeyValuePair(Of DriveScopes, String) In Me.scopeDict
  661.                    Where Scopes.HasFlag(scope.Key)
  662.                    Select scope.Value).ToArray()
  663.  
  664.        End Function
  665.  
  666. #End Region
  667.  
  668. #Region " IDisposable Implementation "
  669.  
  670.        Private isDisposed As Boolean = False
  671.  
  672.        Public Sub Dispose() Implements IDisposable.Dispose
  673.            Me.Dispose(isDisposing:=True)
  674.            GC.SuppressFinalize(obj:=Me)
  675.        End Sub
  676.  
  677.        Private Sub Dispose(isDisposing As Boolean)
  678.  
  679.            If (Not Me.isDisposed) AndAlso (isDisposing) Then
  680.  
  681.                If (Me.client IsNot Nothing) Then
  682.                    Me.client.Dispose()
  683.                    Me.client = Nothing
  684.                End If
  685.  
  686.            End If
  687.  
  688.            Me.isDisposed = True
  689.  
  690.        End Sub
  691.  
  692. #End Region
  693.  
  694.    End Class
  695.  
  696. End Namespace
  697.  
  698. #End Region





• ¿Qué necesito para usar el código de arriba?

Puedes copiar todo el código en un nuevo proyecto de VB.NET para generar una dll que puedes usar sin complicación desde C#, o bien puedes traducir todo el código a C# con cualquier herramienta online de conversión de código VB.NET a C#, como por ejemplo http://converter.telerik.com/ (ojo, no existe la herramienta perfecta, puede producir errores de compilación que necesitarían ser arreglados manuálmente.)

Como ya dije, no me gusta darle todo el trabajo hecho a nadie, pero al menos te doy varias opciones para hacerlo más sencillo :P.


• ¿Cómo utilizo el código de arriba para mis propósitos?

1. Usar la función Authorize / AuthorizeAsync para llevar a cabo la autorización OAuthv2 en Google Drive.

2. Usar la función GetFiles / GetFilesAsyncpara listar los archivos contenidos en tu GoogleDrive, para identificar el archivo que quieres sobreescribir. Dicha función devolverá una colección de objetos Google.Apis.Drive.v3.Data.File, y en la propiedad "File.Id" está expuesto el identificador de cada archivo devuelto. La intención de usar esta función será para obtener dicho identificador.

3. Usar la función UpdateFile / UpdateFileAsync para sobreescribir un archivo existente, pasándole el Id. del archivo (objeto "file") que obtuviste previamente.

Fin. En esencia es así de sencillo.

Si te fijas bien en el código fuente, podrás ver que para cada uno de las funciones escribí un ejemplo de código que demuestra el modo de empleo de cada una. No resulta dificil traducir esos pequeños códigos de ejemplo a C# si lo llegases a necesitar.

Tampoco es necesario que lo uses, simplemente puedes tomar ese código en VB.NET como un punto de partida que puedes reproducir en C#, y extenderlo a tus necesidades.

PD: Me gustaría pensar que este código le podrá servir de utilidad ...a quien sea. ^^

Un saludo!
19  Programación / .NET / Re: [C#] Mover archivos de windows || Isolated Storage en: 23 Julio 2017, 20:04
Hola.

Voy a empezar fuerte. Veamos...

Si quieres seguir mi consejo, entonces aquí debes plantearte el siguiente dilema (o al menos yo en tu lugar me lo plantearía muy seriamente):

- Si quieres crear una Macro, entonces usa cualquier herramienta para crear macros, no necesitas recurrir a un lenguaje de alto nivel como C#, de hecho lo que harías en 5 horas en C#, lo haces en 5 minutos con cualquier herramienta enfocada a las macros.
  Una herramienta excelente sería JitBit Macro Recorder.

- Si quieres usar C# para automatizar de forma programática la subida y sobreescirtura de archivos en Google Drive, entonces olvídate de crear macros, y usa la API de Google Drive para .NET, el resultado será un algoritmo informático optimizado en donde la subida/sobreescritura del archivo se realizaría en segundo plano o background, de forma asincrónica y resumible, y donde podrías controlar cualquier posible fallo/excepción al intentar subir/sobreescribir el archivo. Esta sofisticación, con una macro, requeriría mucho más esfuerzo y análisis en comparación para conseguir hacerlo... y hacerlo medianamente bien.
 
Si tu decisión final es seguir queriendo utilizar C# para desarrollar una macro, pues en mi humilde opinión eso que propones sería lo mismo que pretender estudiar la profesión de maquinista de trenes... sólo para usar trenes de juguete.



Es así, de verdad, para crear una macro en plan "automatizar pulsaciones del teclado y del ratón junto a análisis de comparación de imagen o automatización web" no necesitas C#, y de hecho el resultado no sería tan eficiente ( teniendo en cuenta que para empezar no sabes demasiado bien como hacerlo, y para eso deberías recurrir al aprendizaje de conceptos de software automation en .NET, o recurrir a metodologías rudimentarias con la WinAPI, lo que te llevaría mucho tiempo. ) en comparación con recurrir a una herramienta especializada en crear macros... como por ejemplo la herramienta que ya mencioné más arriba.



Partiendo de la premisa de arriba, y asumiendo que te hayas replanteado el problema para enfocarlo de forma óptima y utilizar C# junto a la API de Google Drive, entonces te explicaré el procedimiento...:

Antes de poder utilizar la API, primero existen unos pasos preeliminares que basicamente consisten en registrar una clave de la API de Google Drive para tu uso personal, con la que generar un archivo.json para poder realizar la autorización OAuthv2 en los servicios de Google Drive desde tu código/aplicación.

Aquí te explican paso a paso el qué y el cómo debes llevar a cabo el registro de la API:
...solo se toma de 5 o 10 minutos en hacerlo.

Step 1: Turn on the Drive API

    Use this wizard to create or select a project in the Google Developers Console and automatically turn on the API. Click Continue, then Go to credentials.
    On the Add credentials to your project page, click the Cancel button.
    At the top of the page, select the OAuth consent screen tab. Select an Email address, enter a Product name if not already set, and click the Save button.
    Select the Credentials tab, click the Create credentials button and select OAuth client ID.
    Select the application type Other, enter the name "Drive API Quickstart", and click the Create button.
    Click OK to dismiss the resulting dialog.
    Click the file_download (Download JSON) button to the right of the client ID.
    Move this file to your working directory and rename it client_secret.json.

Bien. El segundo paso sería descargar/instalar la API v3 de Google Drive para .NET:
( también necesitas descargar todas las dependencias que se indican al pie de página. )

Ten en cuenta que puedes automatizar la instalación de la API de Google Drive ( incluyendo sus dependencias ) en Visual Studio, simplemente creando un nuevo proyecto de C#, abriendo la consola de NuGet y escribiendo el siguiente comando en dicha consola:
Código:
Install-Package Google.Apis.Drive.v3

Llegados a este punto, ahora ya puedes empezar a desarrollar tu algoritmo con la API. Lo primero sería desarrollar una funcionalidad para la autentificación de usuario con la API de Google Drive, seguidamente otra funcionalidad para buscar/identificar el archivo que quieres sobreescribir, y por último implementar la funcionalidad para llevar a cabo la subida/sobreescritura del archivo.

...¿Que cómo se hace todo eso?, pues leyendo y poniendo en práctica todo lo leido, por supuesto, esto no es cosa de "hacer click y listo". Aquí tienes la documentación oficial de la API:


Esto es, mayórmente, sobre lo que debes documentarte:


PD: No es tan dificil como parece. Por si te sirve de ánimos: yo ya hice clientes en .NET con funcionalidades sincrónicas y asincónicas para administrar la cuenta de Youtube, Gmail, y Drive. Aprendido el manejo de uno, aprendidos todos xD, ya que las APIS de cada servicio de Google solo cambian en los nombres de sus miembros, pero su modo de empleo es practicamente idéntico...

Si tienes cualquier duda al respecto, no dudes en preguntar.

Saludos!
20  Foros Generales / Foro Libre / Re: Qué canción estás escuchando ahora ? en: 22 Julio 2017, 21:00
Constance a ver si nos consigues el algoritmo de Elektro...
Hecho
Start----> Process------> End

¿Tan solo 3 miserables pasos de nada, Inicio, Procesar, y Fin?, pues vaya, cualquier persona que te lea se pensará que soy un "simple".  ...Pos que sepas que en la cama hago mucho más que 3 pasos... y durante mucho más que 3 minutos, que a este paso entre los dos me vais a convertir en simple, y neunuco, así que yo mejor me prevengo... :P

Y ya que estamos... voy a compartir un temita de uno de mis grupos favoritos:

Garbage - Sex Is Not The Enemy


Páginas: 1 [2] 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ... 1002
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines