private void SaveLogin(LeanKitAccountAuth account)
{
"Saving LeanKit login information...".Debug();
try
{
var dir = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory;
if (dir == null)
{
throw new Exception("Could not access current directory.");
}
var curFolder = dir.FullName;
var storagefile = Path.Combine(curFolder, "config-edit.json");
var localStorage = new LocalStorage <Configuration>(storagefile);
var config = File.Exists(storagefile) ? localStorage.Load() : new Configuration();
config.LeanKit = new ServerConfiguration
{
Host = account.Hostname,
User = account.Username,
Password = account.Password
};
localStorage.Save(config);
}
catch (Exception ex)
{
string.Format("Error saving login creditials: {0}", ex.Message).Error(ex);
throw;
}
}
private void InitializeLeanKitMonitoring()
{
try
{
var host = ConfigurationManager.AppSettings["LeanKit-AccountName"];
var email = ConfigurationManager.AppSettings["LeanKit-EmailAddress"];
var password = ConfigurationManager.AppSettings["LeanKit-Password"];
var boardIds = ConfigurationManager.AppSettings["LeanKit-BoardId"];
var leanKitAuth = new LeanKitAccountAuth
{
Hostname = host,
Username = email,
Password = password
};
var boardId = int.Parse(boardIds);
_leanKitIntegration = new LeanKitIntegrationFactory().Create(boardId, leanKitAuth);
_leanKitIntegration.BoardChanged += IntegrationOnBoardChanged;
_leanKitIntegration.StartWatching();
}
catch (Exception ex)
{
ShowMessage("Error: " + ex.Message);
}
}
private static string FormatApiRequestInfo(LeanKitAccountAuth leanKitAccountAuth, IRestRequest request, bool hidePassword = false)
{
var accountAuthStringStringBuilder = new StringBuilder();
accountAuthStringStringBuilder.Append("Attempted Authentication Information: ");
accountAuthStringStringBuilder.Append("Hostname: ");
accountAuthStringStringBuilder.Append(leanKitAccountAuth.Hostname != null
? leanKitAccountAuth.Hostname + ", "
: "Unknown, ");
accountAuthStringStringBuilder.Append("Username: "******", "
: "Unknown, ");
if (!hidePassword)
{
accountAuthStringStringBuilder.Append("Password: "******", "
: "Unknown, ");
}
accountAuthStringStringBuilder.Append("Resource: ");
accountAuthStringStringBuilder.Append(request.Resource != null ? request.Resource + ", " : "Unknown, ");
return(accountAuthStringStringBuilder.ToString());
}
/// <summary>
/// Factory method that creates and returns the <see cref="LeanKitIntegration" /> implementation using the
/// LeanKitClient created with the default <see cref="IRestCommandProcessor" />.
/// </summary>
/// <remarks>
/// The default implementation of the <see cref="IRestCommandProcessor" /> uses RestSharp.
/// </remarks>
/// <param name="boardId">The Identity of the Board that will be watched and modified.</param>
/// <param name="accountAuth">The account authentication information used to connect to the LeanKit API.</param>
/// <returns>The <see cref="ILeanKitIntegration" /> used to monitor and modify the specified board. </returns>
public ILeanKitIntegration Create(long boardId, LeanKitAccountAuth accountAuth)
{
var clientFactory = new LeanKitClientFactory();
var apiClient = clientFactory.Create(accountAuth);
return(new LeanKitIntegration(boardId, apiClient));
}
private ILeanKitApi Connect(Request request, bool saveLogin = false)
{
LeanKitClientFactory = new LeanKitClientFactory();
var account = new LeanKitAccountAuth
{
Hostname = request.Host,
Username = request.User,
Password = request.Password,
UrlTemplateOverride = request.Host
};
if (saveLogin)
{
SaveLogin(account);
}
// expand host if necessary
if (account.Hostname == "kanban-cibuild")
{
account.UrlTemplateOverride = "http://kanban-cibuild.localkanban.com/";
}
else if (!account.Hostname.Contains("http://"))
{
account.UrlTemplateOverride = "https://" + account.Hostname + ".leankit.com/";
}
string.Format("Attempting connection to {0}", request).Debug();
return(LeanKitClientFactory.Create(account));
}
public T Post <T>(LeanKitAccountAuth accountAuth, string resource) where T : new()
{
return(Process <T>(accountAuth,
new RestRequest(Method.POST)
{
Resource = resource, RequestFormat = DataFormat.Json
}));
}
internal BoardSubscription(LeanKitAccountAuth auth, long boardId)
{
_boardId = boardId;
LkClientApi = new LeanKitClientFactory().Create(auth);
Integration = new LeanKitIntegrationFactory().Create(_boardId, auth);
new Thread(WatchThread).Start();
}
private static void ValidateResponse(IRestResponse <AsyncResponse> response,
LeanKitAccountAuth leanKitAccountAuth,
IRestRequest request)
{
var requestedResource = GetRequestUri(leanKitAccountAuth.GetAccountUrl());
var logAuthString = FormatApiRequestInfo(leanKitAccountAuth, request, true);
if (response == null)
{
throw new LeanKitAPIException("A failure occurred retrieving the response from the API.");
}
if (response.ResponseUri.Host != requestedResource.Host)
{
throw new InvalidAPIResourceException();
}
if (response.ResponseStatus == ResponseStatus.Error)
{
throw new LeanKitAPIException(response.ErrorException);
}
switch (response.StatusCode)
{
case HttpStatusCode.Unauthorized:
throw new UnauthorizedAccessException(response.StatusDescription + ": " + logAuthString);
}
AsyncResponse responseData = response.Data;
if (responseData == null)
{
throw new LeanKitAPIException("Unable to process the response from the API.");
}
switch ((ResponseCode)responseData.ReplyCode)
{
case ResponseCode.UnauthorizedAccess:
throw new UnauthorizedAccessException(responseData.ReplyText + ": " + logAuthString);
case ResponseCode.NoData:
throw new NoDataException(responseData.ReplyText);
case ResponseCode.FatalException:
case ResponseCode.MinorException:
case ResponseCode.UserException:
throw new LeanKitAPIException(responseData.ReplyText, (ResponseCode)responseData.ReplyCode);
}
//check to make sure there is data
if (string.IsNullOrEmpty(responseData.ReplyData))
{
throw new LeanKitAPIException(responseData.ReplyText + ": " + logAuthString, (ResponseCode)responseData.ReplyCode);
}
}
public T Get <T>(LeanKitAccountAuth accountAuth, string resource, object body) where T : new()
{
var restRequest = new RestRequest(Method.GET)
{
Resource = resource, RequestFormat = DataFormat.Json
};
restRequest.AddBody(body);
return(Process <T>(accountAuth, restRequest));
}
protected override void OnStartFixture()
{
TestConfig = Test <Configuration> .Item;
TestAuth = new LeanKitAccountAuth
{
Hostname = TestConfig.LeanKit.Url,
UrlTemplateOverride = "http://{0}.leankit.com",
Username = TestConfig.LeanKit.User,
Password = TestConfig.LeanKit.Password
};
}
internal BoardSubscription(LeanKitAccountAuth auth, long boardId, int pollingFrequency)
{
_boardId = boardId;
LkClientApi = new LeanKitClientFactory().Create(auth);
var settings = new IntegrationSettings {
CheckForUpdatesIntervalSeconds = pollingFrequency
};
Integration = new LeanKitIntegrationFactory().Create(_boardId, auth, settings);
new Thread(WatchThread).Start();
}
public T Post <T>(LeanKitAccountAuth accountAuth, string resource, object body) where T : new()
{
var restRequest = new RestRequest(Method.POST)
{
Resource = resource,
RequestFormat = DataFormat.Json,
JsonSerializer = new JsonSerializer()
};
restRequest.AddBody(body);
return(Process <T>(accountAuth, restRequest));
}
public ILeanKitApi Subscribe(LeanKitAccountAuth auth, long boardId, Action <long, BoardChangedEventArgs, ILeanKitApi> notification)
{
if (notification == null)
{
throw new Exception("Must provide subscription notification function");
}
lock (BoardSubscriptions)
{
if (!BoardSubscriptions.ContainsKey(boardId))
{
BoardSubscriptions[boardId] = new BoardSubscription(auth, boardId);
}
BoardSubscriptions[boardId].Notifications.Add(notification);
return(BoardSubscriptions[boardId].LkClientApi);
}
}
private T Process <T>(LeanKitAccountAuth accountAuth, IRestRequest request) where T : new()
{
var errorMessages = _validationService.ValidateRequest((RestRequest)request);
if (errorMessages.Count > 0)
{
var ex = new ValidationException("Provided request parameters are invalid.");
ex.Data["ErrorMessages"] = errorMessages;
throw ex;
}
var client = new RestClient
{
BaseUrl = accountAuth.GetAccountUrl(),
Authenticator = new HttpBasicAuthenticator(accountAuth.Username, accountAuth.Password)
};
var response = RetryRequest(request, accountAuth, client);
var asyncResponse = response.Data;
if (string.IsNullOrEmpty(asyncResponse.ReplyData))
{
return(new T());
}
var rawJson = asyncResponse.ReplyData;
var authUserDateFormat = _settings.DateFormat;
var isoDateTimeConverter = new IsoDateTimeConverter {
DateTimeFormat = authUserDateFormat
};
rawJson = rawJson.Substring(1, rawJson.Length - 2);
var retVal = JsonConvert.DeserializeObject <T>(rawJson, new JsonSerializerSettings
{
Error = HandleError,
Converters = { isoDateTimeConverter }
});
return(retVal);
}
//TODO: would be great if we could reload configuration for just a single board
private void ConnectToLeanKit()
{
LeanKitAccount = new LeanKitAccountAuth
{
Hostname = Configuration.LeanKit.Url,
UrlTemplateOverride = GetTemplateOverride(Configuration.LeanKit.Url),
Username = Configuration.LeanKit.User,
Password = Configuration.LeanKit.Password
};
try
{
Log.Debug("Connecting to LeanKit account [{0}] with account [{1}]", LeanKitAccount.Hostname, LeanKitAccount.Username);
LeanKit = LeanKitClientFactory.Create(LeanKitAccount);
}
catch (Exception ex)
{
Log.Error("Failed to open LeanKit API: " + ex.Message);
}
}
public ILeanKitApi Create(LeanKitAccountAuth accountAuth)
{
var leanKitClient = new LeanKitClient(new RestSharpCommandProcessor(new ValidationService(null), new IntegrationSettings()));
return(leanKitClient.Initialize(accountAuth));
}
public ILeanKitApi Initialize(LeanKitAccountAuth accountAuth)
{
_accountAuth = accountAuth;
return(this);
}
public ILeanKitApi Initialize(LeanKitAccountAuth accountAuth)
{
_accountAuth = accountAuth.ToBasicAuth();
return(this);
}
public void RunQuery()
{
ValidateQuery();
var leanKitAuth = new LeanKitAccountAuth
{
Hostname = _args.Host,
Username = _args.User,
Password = _args.Password
};
// For internal development testing
if (_args.Host.Equals("kanban-cibuild", StringComparison.InvariantCultureIgnoreCase))
{
leanKitAuth.UrlTemplateOverride = "http://{0}.localkanban.com";
}
WriteInfo("Connecting to LeanKit account...");
var api = new LeanKitClientFactory().Create(leanKitAuth);
if (_args.Boards)
{
WriteInfo("Getting all boards...");
var boards = api.GetBoards();
var boardList = boards.Select(Mapper.Map <BoardLiteView>);
var output = _args.Csv ? boardList.ToCsv() : _args.Json ? boardList.ToJson() : boardList.Dump();
Console.WriteLine(output);
}
else if (_args.Board > 0)
{
WriteInfo(string.Format("Getting board [{0}]...", _args.Board));
var board = api.GetBoard(_args.Board);
if (_args.Lanes || _args.Lane > 0 || _args.Cards)
{
// Get lanes
var boardLanes = new List <Lane>();
if (_args.Lane > 0)
{
WriteInfo(string.Format("Getting lane [{0}]...", _args.Lane));
boardLanes.AddRange(board.AllLanes().Where(lane => lane.Id == _args.Lane));
}
else
{
if (_args.IncludeBacklog)
{
boardLanes.AddRange(board.Backlog);
}
boardLanes.AddRange(board.Lanes);
if (_args.IncludeArchive)
{
boardLanes.AddRange(board.Archive);
}
}
if (_args.Cards)
{
WriteInfo("Getting cards...");
var cards = new List <MappedCardView>();
foreach (var lane in boardLanes)
{
cards.AddRange(lane.Cards.Select(Mapper.Map <MappedCardView>));
}
// Archived cards is a separate API call
if (_args.IncludeArchive)
{
var archivedCards = api.GetArchiveCards(_args.Board);
cards.AddRange(archivedCards.Select(Mapper.Map <MappedCardView>));
}
var output = _args.Csv ? cards.ToCsv() : _args.Json ? cards.ToJson() : cards.Dump();
Console.WriteLine(output);
}
else
{
var lanes = boardLanes.Select(Mapper.Map <LaneView>);
var output = _args.Csv ? lanes.ToCsv() : _args.Json ? lanes.ToJson() : lanes.Dump();
Console.WriteLine(output);
}
}
else
{
var boardView = Mapper.Map <BoardView>(board);
var output = _args.Csv ? boardView.ToCsv() : _args.Json ? boardView.ToJson() : boardView.Dump();
Console.WriteLine(output);
}
}
}
private static IRestResponse <AsyncResponse> RetryRequest(IRestRequest request, LeanKitAccountAuth accountAuth,
RestClient client)
{
IRestResponse <AsyncResponse> response = new RestResponse <AsyncResponse>();
for (var tryCount = 0; tryCount <= 10; tryCount++)
{
try
{
response = client.Execute <AsyncResponse>(request);
ValidateResponse(response, accountAuth, request);
break;
}
catch (NoDataException)
{
return(response);
}
catch (Exception)
{
if (tryCount == 10)
{
throw;
}
Thread.Sleep(1000);
}
}
return(response);
}
