private static async Task <string> GetToken(string email, string password)
{
string apiUrl = config["apiUrl"];
var req = new WebRequestOptions {
UriString = $"{apiUrl}{Urls.login}"
};
HttpResponseMessage response = await client.PostAsJsonAsync(req.UriString,
new Authorize()
{
Email = email,
Password = password,
TzOffset = 360
});
if (response.IsSuccessStatusCode)
{
string json = await response.Content.ReadAsStringAsync();
var loginResponse = JsonConvert.DeserializeObject <Credential>(json);
return(loginResponse.Token);
}
else
{
Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
}
return("");
}
public static BlobStream GetStream(this WebRequestOptions parms)
{
var request = parms.BuildRequest();
request.Method = "GET";
return(request.ReadStreamResponse());
}
public static string Get(this WebRequestOptions parms)
{
var request = parms.BuildRequest();
request.Method = "GET";
return(request.ReadStringResponse());
}
static List <KeyValuePair <string, byte[]> > Export(string token, string exportdir)
{
string apiUrl = config["apiUrl"];
var req = new WebRequestOptions
{
UriString = $"{apiUrl}{Urls.assessments}",
Headers = new Dictionary <string, string> {
{ "Authorization", token }
}
};
var files = new List <KeyValuePair <string, byte[]> >();
var assessments = req.Get().FromJson <Assessment[]>();
foreach (var id in assessments.Select(x => x.AssessmentId))
{
req.UriString = $"{apiUrl}{Urls.token}?assessmentid={id}&expSeconds=10";
var assmt_token = req.Get().FromJson <Credential>().Token;
if (!string.IsNullOrEmpty(assmt_token))
{
var expreq = new WebRequestOptions {
UriString = $"{apiUrl}{Urls.export}?token={assmt_token}"
};
using (var bs = expreq.GetStream())
{
var filename = bs.FileName.SanitizePathPart();
files.Add(new KeyValuePair <string, byte[]>(filename, bs.Buffer));
var log = $"{filename} | \"Assessment was successfully exported\"";
Console.WriteLine(log);
Log.Information(log);
}
}
}
if (!string.IsNullOrEmpty(exportdir))
{
var dir = new DirectoryInfo(exportdir);
if (!dir.Exists)
{
dir.Create();
}
dir.Clear();
foreach (var file in files)
{
var filepath = Path.Combine(exportdir, file.Key.SanitizePathPart());
filepath = FileHelper.GetSafeFileName(filepath);
File.WriteAllBytes(filepath, file.Value);
}
}
return(files);
}
public static string Post(this WebRequestOptions parms, HttpPostPayload payload)
{
var request = parms.BuildRequest();
request.Method = "POST";
request.ContentType = payload.ContentType;
var buffer = payload.Buffer;
request.ContentLength = buffer.Length;
using (var rs = request.GetRequestStream())
{
rs.Write(buffer, 0, buffer.Length);
}
return(request.ReadStringResponse());
}
static string GetToken(string email, string password)
{
string apiUrl = config["apiUrl"];
var req = new WebRequestOptions {
UriString = $"{apiUrl}{Urls.login}"
};
var resp = req.Post(new HttpPostPayload
{
ContentType = "application/json",
Data = new Authorize
{
Email = email,
Password = password
}.ToJson()
}).FromJson <Credential>();
return(resp.Token);
}
public static WebRequest BuildRequest(this WebRequestOptions parms)
{
var request = (HttpWebRequest)WebRequest.Create(parms.UriString);
if (!string.IsNullOrWhiteSpace(parms.Username))
{
var credentials = new NetworkCredential(parms.Username, parms.Password);
request.Credentials = credentials.GetCredential(parms.Uri, parms.AuthType ?? string.Empty);
}
if (!string.IsNullOrWhiteSpace(parms.Referer))
{
request.Referer = parms.Referer;
}
parms.Headers = parms.Headers ?? new Dictionary <string, string>();
foreach (var kvp in parms.Headers)
{
request.Headers[kvp.Key] = kvp.Value;
}
return(request);
}
static void Import(string token, string importdir, List <KeyValuePair <string, byte[]> > files)
{
string apiUrl = config["apiUrl"];
if (Directory.Exists(importdir))
{
files.Clear();
foreach (var filepath in Directory.GetFiles(importdir, "*.csetw", SearchOption.AllDirectories))
{
var buffer = File.ReadAllBytes(filepath);
files.Add(new KeyValuePair <string, byte[]>(Path.GetFileName(filepath), buffer));
}
}
var req = new WebRequestOptions
{
UriString = $"{apiUrl}{Urls.import}",
Headers = new Dictionary <string, string> {
{ "Authorization", token }
}
};
foreach (var file in files)
{
var filename = file.Key;
var buffer = file.Value;
using (var bs = new BlobStream(filename, "application/octet-stream"))
{
bs.Write(buffer, 0, buffer.Length);
var content = new Dictionary <string, object> {
{ "file", bs }
};
using (var data = MimeMultipartStream.FromContent(content))
{
try
{
var resp = req.Post(new HttpPostPayload
{
ContentType = data.ContentType,
Data = data.Buffer
});
var log = $"{filename} | {resp}";
Console.WriteLine(log);
Log.Information(log);
}
catch (WebException ex)
{
using (var stream = ex.Response.GetResponseStream())
{
using (var reader = new StreamReader(stream))
{
var json = reader.ReadToEnd();
var err = JObject.Parse(json);
var log = $"{filename} | \"Failed to import assessment\"";
Console.WriteLine(log);
Log.Error(ex, log);
Log.Error("Server-Message: {0}", err.Value <string>("Message"));
Log.Error("Server-ExceptionType: {0}", err.Value <string>("ExceptionType"));
Log.Error("Server-ExceptionMessage: {0}", err.Value <string>("ExceptionMessage"));
Log.Error("Server-StackTrace: {0}", err.Value <string>("StackTrace"));
}
}
}
}
}
}
}
