/// <summary>
/// Exports a batch of entries to the database
/// </summary>
/// <param name="csentries">A list of changes to export</param>
/// <returns>The results of the batch export</returns>
public PutExportEntriesResults PutExportEntries(IList <CSEntryChange> csentries)
{
try
{
this.client = new AcmaSyncServiceClient();
PutExportEntriesResults exportEntriesResults = new PutExportEntriesResults();
IList <AttributeChange> anchorchanges = new List <AttributeChange>();
ExportRequest request = new ExportRequest();
request.CSEntryChanges = csentries;
Logger.WriteLine("Exporting page of {0} objects", csentries.Count);
ExportResponse response = this.client.ExportPage(request);
Logger.WriteLine("Got response of {0} objects", response.Results.Count);
foreach (CSEntryChangeResult item in response.Results)
{
exportEntriesResults.CSEntryChangeResults.Add(item);
}
return(exportEntriesResults);
}
catch (Exception ex)
{
Logger.WriteException(ex);
throw;
}
}
public async Task <ActionResult> Import()
{
var files = Request.Form.Files;
if (files == null)
{
throw new ArgumentNullException(nameof(files));
}
var settingsFile = files.First();
if (!settingsFile.FileName.EndsWith(".json"))
{
throw new IdentityServerManagerException(
ErrorCodes.UnhandledExceptionCode,
ErrorDescriptions.TheFileExtensionIsNotCorrect);
}
var content = string.Empty;
using (var memoryStream = new MemoryStream())
{
await settingsFile.CopyToAsync(memoryStream);
memoryStream.Position = 0;
using (var reader = new StreamReader(memoryStream))
{
content = await reader.ReadToEndAsync();
}
}
ExportResponse response = null;
try
{
response = JsonConvert.DeserializeObject <ExportResponse>(content);
}
catch
{
throw new IdentityServerManagerException(ErrorCodes.UnhandledExceptionCode,
ErrorDescriptions.TheFileIsNotWellFormed);
}
if (!await _manageActions.Import(response.ToParameter()))
{
return(new StatusCodeResult((int)HttpStatusCode.InternalServerError));
}
await _representationManager.AddOrUpdateRepresentationAsync(this, ClientsController.GetClientsStoreName);
return(new NoContentResult());
}
public static ImportParameter ToParameter(this ExportResponse export)
{
if (export == null)
{
throw new ArgumentNullException(nameof(export));
}
return(new ImportParameter
{
Clients = export.Clients == null ? null : export.Clients.Select(c => c.ToModel())
});
}
public async Task <ExportResponse> Export(DateTime from, DateTime to, ICollection <string> events = null, string where = "", string bucket = "")
{
var stream = await this.ExportStream(from, to, events, where, bucket);
var reader = new StreamReader(stream);
var exportResponse = new ExportResponse();
while (reader.Peek() > -1)
{
exportResponse.Add(JsonConvert.DeserializeObject <Event>(reader.ReadLine()));
}
return(exportResponse);
}
private Error[] HandleRequestImpl(BuildData buildData)
{
if (this.platform == null)
{
return(new Error[] {
new Error()
{
Message = "No platform by the name of '" + this.platformId + "'"
}
});
}
ExportResponse response = CbxVmBundleExporter.Run(this.platform, buildData.ExportProperties.ProjectDirectory, buildData.ExportProperties.OutputDirectory, buildData);
return(response.Errors);
}
public ExportResponse ExportPage(ExportRequest request)
{
try
{
Monitor.Enter(ServiceMain.Lock);
ExportResponse response = new ExportResponse();
response.Results = new List <CSEntryChangeResult>();
IList <AttributeChange> anchorchanges;
foreach (CSEntryChange csentryChange in request.CSEntryChanges)
{
try
{
bool referenceRetryRequired;
anchorchanges = CSEntryExport.PutExportEntry(csentryChange, out referenceRetryRequired);
if (referenceRetryRequired)
{
Logger.WriteLine(string.Format("Reference attribute not available for csentry {0}. Flagging for retry", csentryChange.DN));
response.Results.Add(CSEntryChangeResult.Create(csentryChange.Identifier, anchorchanges, MAExportError.ExportActionRetryReferenceAttribute));
}
else
{
response.Results.Add(CSEntryChangeResult.Create(csentryChange.Identifier, anchorchanges, MAExportError.Success));
}
}
catch (Exception ex)
{
MAStatistics.AddExportError();
response.Results.Add(this.GetExportChangeResultFromException(csentryChange, ex));
}
}
return(response);
}
finally
{
Monitor.Exit(ServiceMain.Lock);
}
}
public ExportResponse Export([FromBody] ExportRequest request)
{
var response = new ExportResponse();
var user = DataAccess.GetUser(request.UserId);
var attachmentData = new byte[0];
// generate the report
switch (request.Format)
{
case "CSV":
attachmentData = Reporting.GenerateCSVReport(request.ActivityId, request.FromDate, request.ToDate);
break;
}
// email the report
Mailer.SendMessage("*****@*****.**", user.Email, "Your report from The Outdoor Logbook", "Test body", attachmentData, $"activity report.{request.Format.ToLower()}");
// return the result
response.Success = true;
response.Message = $"Your report has been emailed to {user.Email}.";
return(response);
}
public ExportResponseTests()
{
_response = new ExportResponse("filename", "content");
}
