private async Task SendAttachments(int itemId)
{
try
{
var attachments = _attachementView.GetAttachments();
int filesSent = 0;
if (attachments.Count > 0)
{
foreach (var item in attachments)
{
string attachmentURL = string.Format("{0}({1})/AttachmentFiles/add(FileName='{2}')",
SPUtility.GetListURL(ReportType.FlighCrewVoyage), itemId, item.FileName);
item.SaveToURL = attachmentURL;
lblLoading.Text += "Sending - " + item.FileName + Environment.NewLine;
var attachemntResponse = await item.PostAttachment();
if (!attachemntResponse.IsSuccessStatusCode)
{
var msg = await attachemntResponse.Content.ReadAsStringAsync();
lblLoading.Text += "Failed - " + item.FileName + " - " + msg + Environment.NewLine;
}
else
{
filesSent++;
lblLoading.Text += "Sent - " + item.FileName + Environment.NewLine;
// let sharepoint to complete its task before sending a new one
await Task.Delay(1000);
}
}
}
if (filesSent == attachments.Count)
{
await DisplayAlert("Success", "Item created successfully", "Ok");
}
else
{
await DisplayAlert("Info", lblLoading.Text, "Ok");
}
MessagingCenter.Send(this, "home");
}
catch (Exception ex)
{
await DisplayAlert("Error", ex.Message, "Ok");
}
}
protected async void BindMORPicker()
{
if (!SPUtility.IsConnected())
{
BindMORSavedInfo();
return;
}
var client = await OAuthHelper.GetHTTPClientAsync();
if (client == null)
{
return;
}
try
{
string url = SPUtility.GetListURL(ReportType.MORType);
var result = await client.GetStringAsync(url);
if (result != null)
{
App.DAUtil.RefreshMasterInfo(new MasterInfo {
content = result, Name = "MORItems"
});
var spData = JsonConvert.DeserializeObject <SPData>(result, new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None
});
foreach (var val in spData.d.results)
{
MORpicker.Items.Add(val.Title);
}
SetMORPickerValue();
}
}
catch (Exception ex)
{
BindMORSavedInfo();
var msg = "Unable to fetch MOR items: " + ex.Message;
await DisplayAlert("Error", msg, "Ok");
}
}
public static async Task <int> CreateItemsOffline(List <OfflineItem> items)
{
var client = await OAuthHelper.GetHTTPClientAsync();
try
{
int count = 0;
foreach (OfflineItem oItem in items)
{
try
{
string url = GetListURL((ReportType)oItem.ReportType);
if (string.IsNullOrEmpty(url))
{
if (string.IsNullOrEmpty(oItem.Error))
{
oItem.Error = "Invalid url";
App.DAUtil.Update(oItem);
}
continue;
}
if (oItem.InProgress)
{
continue;
}
var contents = new StringContent(oItem.Value);
oItem.InProgress = true;
RefreshofflineItem(oItem);
contents.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json;odata=verbose");
var postResult = await client.PostAsync(url, contents);
if (postResult.IsSuccessStatusCode)
{
string[] paths = GetPathsFromAttachemntInfo(oItem.Attachments);
if (paths == null)
{
count++;
RemoveOfflineItem(oItem);
continue;
}
foreach (string path in paths)
{
if (string.IsNullOrEmpty(path))
{
continue;
}
try
{
var spData = JsonConvert.DeserializeObject <SPData>(await postResult.Content.ReadAsStringAsync(),
new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None
});
Attachment attachment = new Attachment(path);
int itemId = spData.d.Id;
string attachmentURL = string.Format("{0}({1})/AttachmentFiles/add(FileName='{2}')",
SPUtility.GetListURL((ReportType)oItem.ReportType), itemId, attachment.FileName);
attachment.SaveToURL = attachmentURL;
await Task.Delay(1000);
App.attachments.Add(attachment);
}
catch (Exception ex)
{
oItem.Error = $"Error - {ex.Message}";
oItem.InProgress = false;
RefreshofflineItem(oItem);
continue;
}
}
count++;
RemoveOfflineItem(oItem);
}
else
{
oItem.Error = postResult.ReasonPhrase + "-" + await postResult.Content.ReadAsStringAsync();
oItem.InProgress = false;
RefreshofflineItem(oItem);
continue;
}
}
catch (Exception ex)
{
oItem.InProgress = false;
oItem.Error = $"{ex.Message + Environment.NewLine} Info - + {ex.StackTrace}";
RefreshofflineItem(oItem);
}
}
MessagingCenter.Send(App.offlineItems, REFRESH_OFFLINE_ITEMS);
return(count);
}
catch (Exception ex)
{
DependencyService.Get <IMessage>().LongAlert($"Offline items failed - {ex.Message} - {ex.StackTrace}");
}
return(0);
}
protected async void CreateItems <U>(U reportObject) where U : class
{
try
{
ToggleBusy(true);
var client = await GetHTTPClient();
var data = reportObject;
var body = JsonConvert.SerializeObject(data, Formatting.None,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
var contents = new StringContent(body);
contents.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json;odata=verbose");
if (CheckConnection())
{
Device.BeginInvokeOnMainThread(async() =>
{
string url = SPUtility.GetListURL(ReportType.FlighCrewVoyage);
var postResult = await client.PostAsync(url, contents);
if (postResult.IsSuccessStatusCode)
{
App.DAUtil.Delete(_flightcrew);
lblLoading.Text = "Item created successfully." + Environment.NewLine;
var spData = JsonConvert.DeserializeObject <SPData>(postResult.Content.ReadAsStringAsync().Result,
new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None
});
int itemId = spData.d.Id;
await Task.Delay(500);
await SendAttachments(itemId);
MessagingCenter.Send(this, "home");
}
else
{
var ex = await postResult.Content.ReadAsStringAsync();
await DisplayAlert("Error", ex, "Ok");
}
ToggleBusy(false);
});
}
else
{
SaveOfflineItem(body, ReportType.FlighCrewVoyage, _attachementView.GetAttachmentInfoAsString());
await DisplayAlert("", "Item stored in local storage", "Ok");
ToggleBusy(false);
MessagingCenter.Send(this, "home");
}
}
catch (HttpRequestException ex)
{
DependencyService.Get <IMessage>().ShortAlert("Upload Error");
}
catch (Exception ex)
{
DependencyService.Get <IMessage>().ShortAlert("Upload Error" + ex.Message);
}
}
protected void CreateItems <U>(U reportObject, ReportType reportType) where U : class
{
try
{
ToggleBusy(true);
Device.BeginInvokeOnMainThread(async() =>
{
var client = await OAuthHelper.GetHTTPClientAsync();
var data = reportObject;
string body = "";
try
{
body = JsonConvert.SerializeObject(data, Formatting.None,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
}
catch (Exception ex)
{
await DisplayAlert("Error", ex.Message, "Ok");
}
if (string.IsNullOrEmpty(body))
{
await DisplayAlert("Error", "There is no content to send! - serializtion failed", "Ok");
return;
}
var contents = new StringContent(body);
contents.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json;odata=verbose");
if (CheckConnection())
{
var postResult = await client.PostAsync(SPUtility.GetListURL(reportType), contents);
if (postResult.IsSuccessStatusCode)
{
lblLoading.Text = "Item created successfully." + Environment.NewLine;
var spData = JsonConvert.DeserializeObject <SPData>(postResult.Content.ReadAsStringAsync().Result,
new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None
});
int itemId = spData.d.Id;
await Task.Delay(500);
await SendAttachments(itemId, reportType);
MessagingCenter.Send <SSIRShortForm>(this, "home");
}
else
{
var ex = await postResult.Content.ReadAsStringAsync();
await DisplayAlert("Error", ex, "Ok");
}
}
else
{
SPUtility.SaveOfflineItem(body, reportType, _attachementView.GetAttachmentInfoAsString());
await DisplayAlert("", "Item stored in local storage", "Ok");
MessagingCenter.Send <object>(this, "StartService");
MessagingCenter.Send(this, "home");
}
ToggleBusy(false);
});
}
catch (HttpRequestException ex)
{
DependencyService.Get <IMessage>().ShortAlert("Upload Error");
}
catch (Exception ex)
{
DependencyService.Get <IMessage>().ShortAlert("Upload Error" + ex.Message);
}
}