public ILeanKitIntegration Create(long boardId, ILeanKitAccountAuth accountAuth, IntegrationSettings settings)
{
var clientFactory = new LeanKitClientFactory();
var apiClient = clientFactory.Create(accountAuth);
return(new LeanKitIntegration(boardId, apiClient, settings));
}
public AssetFile Download(ILeanKitAccountAuth accountAuth, string resource)
{
var request = WebRequest.Create(accountAuth.GetAccountUrl() + resource) as HttpWebRequest;
if (request == null)
{
throw new Exception("Error downloading file. Could not create HttpWebRequest");
}
request.UserAgent = _leanKitUserAgent;
AddAuth(request, accountAuth);
var response = request.GetResponse() as HttpWebResponse;
byte[] fileBytes;
using (var responseStream = response.GetResponseStream())
{
var buffer = new byte[4096];
using (var ms = new MemoryStream())
{
int read;
while ((read = responseStream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
fileBytes = ms.ToArray();
}
}
return(new AssetFile
{
FileBytes = fileBytes,
ContentType = response.ContentType,
ContentLength = response.ContentLength
});
}
public T Post <T>(ILeanKitAccountAuth accountAuth, string resource) where T : new()
{
return(Process <T>(accountAuth,
new RestRequest(Method.POST)
{
Resource = resource, RequestFormat = DataFormat.Json
}));
}
internal BoardSubscription(ILeanKitAccountAuth 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();
}
private static void ValidateResponse(IRestResponse <AsyncResponse> response,
ILeanKitAccountAuth 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 != null && 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 ILeanKitApi Create(ILeanKitAccountAuth accountAuth, string dateFormat)
{
var settings = new IntegrationSettings()
{
DateFormat = dateFormat
};
var leanKitClient = new LeanKitClient(new RestSharpCommandProcessor(new ValidationService(null), settings));
return(leanKitClient.Initialize(accountAuth));
}
public T Get <T>(ILeanKitAccountAuth 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 LeanKitBasicAuth
{
Hostname = TestConfig.LeanKit.Url,
UrlTemplateOverride = "http://{0}.leankit.com",
Username = TestConfig.LeanKit.User,
Password = TestConfig.LeanKit.Password
};
}
private static void AddAuth(WebRequest request, ILeanKitAccountAuth auth)
{
if (auth is LeanKitBasicAuth)
{
var basicAuth = auth as LeanKitBasicAuth;
request.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.Default.GetBytes(basicAuth.Username + ":" + basicAuth.Password)));
}
else if (auth is LeanKitTokenAuth)
{
request.Headers.Add("Authorization", "Token " + (auth as LeanKitTokenAuth).Token);
}
}
internal BoardSubscription(ILeanKitAccountAuth 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>(ILeanKitAccountAuth 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));
}
private static IAuthenticator GetAuthenticator(ILeanKitAccountAuth auth)
{
if (auth is LeanKitBasicAuth)
{
var basicAuth = auth as LeanKitBasicAuth;
return(new HttpBasicAuthenticator(basicAuth.Username, basicAuth.Password));
}
if (auth is LeanKitTokenAuth)
{
return(new TokenAuthenticator((auth as LeanKitTokenAuth).Token));
}
throw new ArgumentException("Unknown ILeanKitAccountAuth type");
}
public ILeanKitApi Subscribe(ILeanKitAccountAuth auth, long boardId, int pollingFrequency, 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, pollingFrequency);
}
BoardSubscriptions[boardId].Notifications.Add(notification);
return BoardSubscriptions[boardId].LkClientApi;
}
}
public ILeanKitApi Subscribe(ILeanKitAccountAuth auth, long boardId, int pollingFrequency, Action <long, BoardChangedEventArgs, ILeanKitApi> notification)
{
if (notification == null)
{
throw new Exception("Must provide subscription notification function");
}
lock (BoardSubscriptions)
{
if (BoardSubscriptions.ContainsKey(boardId))
{
return(BoardSubscriptions[boardId].LkClientApi);
}
BoardSubscriptions[boardId] = new BoardSubscription(auth, boardId, pollingFrequency);
BoardSubscriptions[boardId].Notifications.Add(notification);
return(BoardSubscriptions[boardId].LkClientApi);
}
}
private T Process <T>(ILeanKitAccountAuth 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 = new Uri(accountAuth.GetAccountUrl()),
Authenticator = GetAuthenticator(accountAuth),
UserAgent = LeanKitUserAgent
};
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);
}
private static string FormatApiRequestInfo(ILeanKitAccountAuth 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, ");
var basicAuth = leanKitAccountAuth as LeanKitBasicAuth;
if (basicAuth != null)
{
accountAuthStringStringBuilder.Append("Username: "******", "
: "Unknown, ");
if (!hidePassword)
{
accountAuthStringStringBuilder.Append("Password: "******", "
: "Unknown, ");
}
}
var tokenAuth = leanKitAccountAuth as LeanKitTokenAuth;
if (tokenAuth != null && !hidePassword)
{
accountAuthStringStringBuilder.Append("Token: ");
accountAuthStringStringBuilder.Append(tokenAuth.Token != null
? tokenAuth.Token + ", "
: "Unknown, ");
}
accountAuthStringStringBuilder.Append("Resource: ");
accountAuthStringStringBuilder.Append(request.Resource != null ? request.Resource + ", " : "Unknown, ");
return(accountAuthStringStringBuilder.ToString());
}
public T PostFile <T>(ILeanKitAccountAuth accountAuth, string resource, Dictionary <string, object> parameters, string fileName, string mimeType, byte[] fileBytes) where T : new()
{
var boundary = string.Format("----------{0:N}", Guid.NewGuid());
var contentType = "multipart/form-data; boundary=" + boundary;
var formBytes = GetMultipartFormData(parameters, boundary, fileName, mimeType, fileBytes);
var request = WebRequest.Create(accountAuth.GetAccountUrl() + resource) as HttpWebRequest;
if (request == null)
{
throw new Exception("Error posting file. Could not create HttpWebRequest");
}
request.Method = "POST";
request.ContentType = contentType;
request.ContentLength = formBytes.Length;
request.UserAgent = _leanKitUserAgent;
AddAuth(request, accountAuth);
using (var requestStream = request.GetRequestStream())
{
requestStream.Write(formBytes, 0, formBytes.Length);
requestStream.Close();
}
var response = request.GetResponse() as HttpWebResponse;
var responseStream = new StreamReader(response.GetResponseStream());
var result = responseStream.ReadToEnd();
response.Close();
//var task = PostFileAsync(accountAuth, resource, parameters, fileName, fileBytes);
//var result = task.Result;
if (string.IsNullOrEmpty(result))
{
return(new T());
}
var asyncResponse = JsonConvert.DeserializeObject <AsyncResponse2>(result);
if (asyncResponse == null || asyncResponse.ReplyData == null || asyncResponse.ReplyData.Length == 0)
{
return(new T());
}
var rawJson = asyncResponse.ReplyData[0].ToString();
if (string.IsNullOrEmpty(rawJson))
{
return(new T());
}
var authUserDateFormat = _settings.DateFormat + " hh:mm:ss t";
var retVal = JsonConvert.DeserializeObject <T>(rawJson, new JsonSerializerSettings
{
Error = HandleError,
DateFormatString = authUserDateFormat
});
return(retVal);
}
public ILeanKitApi Initialize(LeanKitAccountAuth accountAuth)
{
_accountAuth = accountAuth.ToBasicAuth();
return(this);
}
public ILeanKitApi Initialize(ILeanKitAccountAuth accountAuth)
{
_accountAuth = accountAuth;
return(this);
}
public ILeanKitApi Initialize(LeanKitAccountAuth accountAuth)
{
_accountAuth = accountAuth.ToBasicAuth();
return this;
}
public ILeanKitApi Initialize(ILeanKitAccountAuth accountAuth)
{
_accountAuth = accountAuth;
return this;
}
public ILeanKitApi Create(ILeanKitAccountAuth accountAuth)
{
var leanKitClient = new LeanKitClient(new RestSharpCommandProcessor(new ValidationService(null), new IntegrationSettings()));
return(leanKitClient.Initialize(accountAuth));
}
public ILeanKitIntegration Create(long boardId, ILeanKitAccountAuth accountAuth, IntegrationSettings settings)
{
var clientFactory = new LeanKitClientFactory();
var apiClient = clientFactory.Create(accountAuth);
return new LeanKitIntegration(boardId, apiClient, settings);
}
private static IRestResponse <AsyncResponse> RetryRequest(IRestRequest request, ILeanKitAccountAuth 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);
}
public ILeanKitApi Create(ILeanKitAccountAuth accountAuth)
{
var leanKitClient = new LeanKitClient(new RestSharpCommandProcessor(new ValidationService(null), new IntegrationSettings()));
return leanKitClient.Initialize(accountAuth);
}
protected override void OnStartFixture()
{
TestConfig = Test<Configuration>.Item;
TestAuth = new LeanKitBasicAuth
{
Hostname = TestConfig.LeanKit.Url,
UrlTemplateOverride = "http://{0}.leankit.com",
Username = TestConfig.LeanKit.User,
Password = TestConfig.LeanKit.Password
};
}
public ILeanKitApi Create(ILeanKitAccountAuth accountAuth, string dateFormat)
{
var settings = new IntegrationSettings() {DateFormat = dateFormat};
var leanKitClient = new LeanKitClient(new RestSharpCommandProcessor(new ValidationService(null), settings));
return leanKitClient.Initialize(accountAuth);
}
