Cómo puedo obtener acceso al SVN pre-mensaje de confirmación mediante SharpSVN?

Question

veo que todo lo que puedo conjunto a es %repos% y %txn%

¿cómo puedo usar esos para llegar al mensaje de confirmación (en mi caso, para analizar el número de ticket para que yo pueda ver si existe en la base de datos de errores antes de ejecutarlo)

Answer 1

El uso de un SharpSvn suelta puede utilizar

SvnHookArguments ha; 
if (!SvnHookArguments.ParseHookArguments(args, SvnHookType.PreCommit, false, out ha))
{
    Console.Error.WriteLine("Invalid arguments");
    Environment.Exit(1);  
}

para analizar los argumentos de un pre-commit gancho y luego usar

using (SvnLookClient cl = new SvnLookClient())
{
    SvnChangeInfoEventArgs ci;

    cl.GetChangeInfo(ha.LookOrigin, out ci);


    // ci contains information on the commit e.g.
    Console.WriteLine(ci.LogMessage); // Has log message

    foreach (SvnChangeItem i in ci.ChangedPaths)
    {

    }
}

para llegar al mensaje de registro, archivos cambiado, etc.

Answer 2

No sé SharpSVN, sin embargo, si crea un script gancho que usted describe, que se obtiene como argumentos% repos% y% TXN%

Con estos datos se puede mirar en la transacción (% TXN%) del repositorio dado. Por lo general, esto se hace mediante

svnlook -t %txn%  %repo%

A continuación, obtendrá el mensaje de informe.

Así que usted debe buscar un equivalente a svnlook en la interfaz sharpSVN.

Answer 3

Hace algún tiempo he escrito un C# contenedor para el svnlook.exe.He usado para enviar mensajes de confirmación para un sistema de seguimiento de fallos (si un ticket id fue siempre).Encontrar a continuación, tal vez sea útil para usted.

/// <summary>
/// Encapsulates the SVNLook command in all of it's flavours
/// </summary>
public static class SvnLookCommand
{
    /// <summary>
    /// The string &quot;&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string AUTHOR = "author";

    /// <summary>
    /// The string &quot;cat&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string CAT = "cat";

    /// <summary>
    /// The string &quot;changed&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string CHANGED = "changed";

    /// <summary>
    /// The string &quot;date&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string DATE = "date";

    /// <summary>
    /// The string &quot;diff&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string DIFF = "diff";

    /// <summary>
    /// The string &quot;dirs-changed&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string DIRSCHANGED = "dirs-changed";

    /// <summary>
    /// The string &quot;history&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string HISTORY = "history";

    /// <summary>
    /// The string &quot;info&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string INFO = "info";

    /// <summary>
    /// The string &quot;lock&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string LOCK = "lock";

    /// <summary>
    /// The string &quot;log&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string LOG = "log";

    /// <summary>
    /// The string &quot;tree&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string TREE = "tree";

    /// <summary>
    /// The string &quot;uuid&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string UUID = "uuid";

    /// <summary>
    /// The string &quot;youngest&quot; used as parameter for the svnlook.exe
    /// </summary>
    private static readonly string YOUNGEST = "youngest";

    /// <summary>
    /// The full path of the svnlook.exe binary
    /// </summary>
    private static string commandPath = String.Empty;

    /// <summary>
    /// Initializes static members of the <see cref="SvnLookCommand"/> class.
    /// </summary>
    static SvnLookCommand()
    {
        commandPath = Settings.Default.SvnDirectoryPath;

        if (!Path.IsPathRooted(commandPath))
        {
            Assembly entryAssembly = Assembly.GetEntryAssembly();
            if (entryAssembly != null)
            {
                commandPath = new FileInfo(entryAssembly.Location).Directory.ToString() + Path.DirectorySeparatorChar + commandPath;
            }
        }

        if (!commandPath.EndsWith(Path.DirectorySeparatorChar.ToString()))
        {
            commandPath = commandPath + Path.DirectorySeparatorChar;
        }

        commandPath += "svnlook.exe";
    }

    /// <summary>
    /// Gets the process info to start a svnlook.exe command with parameter &quot;author&quot;
    /// </summary>
    /// <param name="repository">The repository.</param>
    /// <param name="revision">The revision.</param>
    /// <returns>Gets the author of the revision in scope</returns>
    public static ProcessStartInfo GetAuthor(string repository, string revision)
    {
        ProcessStartInfo svnLookProcessStartInfo = new ProcessStartInfo(commandPath);
        svnLookProcessStartInfo.Arguments = String.Format("{0} {1} -r {2}", AUTHOR, repository, revision);
        return svnLookProcessStartInfo;
    }

    /// <summary>
    /// Gets the process info to start a svnlook.exe command with parameter &quot;log&quot;
    /// </summary>
    /// <param name="repository">The repository.</param>
    /// <param name="revision">The revision.</param>
    /// <returns>The svn log of the revision in scope</returns>
    public static ProcessStartInfo GetLog(string repository, string revision)
    {
        ProcessStartInfo svnLookProcessStartInfo = new ProcessStartInfo(commandPath);
        svnLookProcessStartInfo.Arguments = String.Format("{0} {1} -r {2}", LOG, repository, revision);
        return svnLookProcessStartInfo;
    }

    /// <summary>
    /// Gets the process info to start a svnlook.exe command with parameter &quot;changed&quot;
    /// </summary>
    /// <param name="repository">The repository.</param>
    /// <param name="revision">The revision.</param>
    /// <returns>The change log of the revision in scope</returns>
    public static ProcessStartInfo GetChangeLog(string repository, string revision)
    {
        ProcessStartInfo svnLookProcessStartInfo = new ProcessStartInfo(commandPath);
        svnLookProcessStartInfo.Arguments = String.Format("{0} {1} -r {2}", CHANGED, repository, revision);
        return svnLookProcessStartInfo;
    }

    /// <summary>
    /// Gets the process info to start a svnlook.exe command with parameter &quot;info&quot;
    /// </summary>
    /// <param name="repository">The repository.</param>
    /// <param name="revision">The revision.</param>
    /// <returns>The info of the revision in scope</returns>
    public static ProcessStartInfo GetInfo(string repository, string revision)
    {
        ProcessStartInfo svnLookProcessStartInfo = new ProcessStartInfo(commandPath);
        svnLookProcessStartInfo.Arguments = String.Format("{0} {1} -r {2}", INFO, repository, revision);
        return svnLookProcessStartInfo;
    }
}

Answer 4

He acaban de pasar por el proceso de construcción de una aplicación para mí y ganchos SharpSVN no se requiere para mirar los mensajes de confirmación. Suponiendo que se ha construido a sí mismo una aplicación de consola ya, probar este código que llama directamente svnlook.exe:

string repos = args[0];
string txn = args[1];

var processStartInfo = new ProcessStartInfo
{
  FileName = "svnlook.exe",
  UseShellExecute = false,
  CreateNoWindow = true,
  RedirectStandardOutput = true,
  RedirectStandardError = true,
  Arguments = String.Format("log -t \"{0}\" \"{1}\"", txn, repos)
};

Process process = Process.Start(processStartInfo);
string message = process.StandardOutput.ReadToEnd();
process.WaitForExit();
return message;

Asegúrese de que se añade la ubicación de svnlook.exe al entorno variable de ruta de la máquina lo que lo anterior puede ser ejecutado desde cualquier lugar.