private async Task <IList <Result> > GetTasks()
{
try
{
var client = await OAuthHelper.GetHTTPClientAsync();
var response = await client.GetStringAsync(SPTasksURL);
if (response != null)
{
var spData = JsonConvert.DeserializeObject <SPData>(response, new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None
});
if (spData != null)
{
return(spData.d.results);
}
}
}
catch (Exception ex)
{
Device.BeginInvokeOnMainThread(() =>
{
DependencyService.Get <IMessage>().ShortAlert(ex.Message);
IsBusy = false;
});
}
return(null);
}
public static async Task<List<PeoplePicker>> GetUsersForPicker()
{
if (!SPUtility.IsConnected())
{
return GetUsers();
}
var client = await OAuthHelper.GetHTTPClientAsync();
try
{
var response = await client.GetStringAsync(ClientConfiguration.Default.SPRootURL + "web/siteusers?");
if (response != null)
{
App.DAUtil.RefreshMasterInfo(new MasterInfo { Name = "Users", content = response });
return ResponseToUsers(response);
}
}
catch (Exception ex)
{
return GetUsers();
}
return null;
}
public static async Task<string[]> GetAirCraftRegistrations()
{
MasterInfo mInfo = null;
if (!SPUtility.IsConnected())
{
mInfo = App.DAUtil.GetMasterInfoByName("AircraftRegistrations");
}
else
{
try
{
var client = await OAuthHelper.GetHTTPClientAsync();
var url = GetListURL(ReportType.AircraftRegistration);
var response = await client.GetStringAsync(url);
if (response != null)
{
mInfo = new MasterInfo { Name = "AircraftRegistrations", content = response };
App.DAUtil.RefreshMasterInfo(mInfo);
}
}
catch (Exception ex)
{
mInfo = App.DAUtil.GetMasterInfoByName("AircraftRegistrations");
}
}
if (mInfo != null)
{
var stations = JsonConvert.DeserializeObject<SPData>(mInfo.content);
return stations.d.results.Select(x => x.Aircraft_x0020_Registration).ToArray();
}
return null;
}
public async Task <List <DataContracts.Result> > GetDocuments(string folderPath, bool isFiles)
{
try
{
var client = await OAuthHelper.GetHTTPClientAsync();
string url = string.Format(SPDocumentLibraryURL, folderPath, isFiles ? "Files" : "Folders");
var response = await client.GetStringAsync(url);
if (response != null)
{
var folders = JsonConvert.DeserializeObject <SPFolder>(response, new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None
});
if (folders != null)
{
return(folders.d.results.ToList());
}
}
}
catch (Exception ex)
{
}
return(null);
}
public static async Task<List<OperatingPlan>> GetOperatingPlans()
{
MasterInfo mInfo = null;
if (!SPUtility.IsConnected())
{
mInfo = App.DAUtil.GetMasterInfoByName("OperatingPlans");
}
else
{
try
{
var client = await OAuthHelper.GetHTTPClientAsync();
var response = await client.GetStringAsync(GetListURL(ReportType.OperationPlan));
if (response != null)
{
mInfo = new MasterInfo { Name = "OperatingPlans", content = response };
App.DAUtil.RefreshMasterInfo(mInfo);
}
}
catch (Exception)
{
mInfo = App.DAUtil.GetMasterInfoByName("OperatingPlans");
}
}
if (mInfo != null)
{
var stations = await GetStations();
try
{
var oPlans = JsonConvert.DeserializeObject<SPData>(mInfo.content, new JsonSerializerSettings
{
DateParseHandling = DateParseHandling.None,
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
});
return oPlans.d.results.Select(x => new OperatingPlan
{
FlighNumber = x.Flight_x0020_Number,
ArrivalStationId = Convert.ToString(x.Arrival_x0020_StationId),
DepartureStationId = Convert.ToString(x.Departure_x0020_StationId),
ArrivalStation = stations[Convert.ToString(x.Arrival_x0020_StationId)],
DepartureStation = stations[Convert.ToString(x.Departure_x0020_StationId)]
}).ToList();
}
catch (Exception ex)
{
}
}
return null;
}
private async Task <HttpClient> GetHTTPClient()
{
var client = await OAuthHelper.GetHTTPClientAsync();
if (client == null)
{
return(null);
}
return(client);
}
public static async Task<List<Value>> GetAttachedFilesForItem(string itemUrl)
{
var client = await OAuthHelper.GetHTTPClientAsync();
var response = await client.GetStringAsync($"{itemUrl}/AttachmentFiles");
if (response != null)
{
var files = JsonConvert.DeserializeObject<LookUp>(response);
return files.value;
}
return null;
}
public async Task LoadNotifications()
{
try
{
Device.BeginInvokeOnMainThread(() =>
{
IsBusy = true;
});
List <NotificationItem> items = new List <NotificationItem>();
var client = await OAuthHelper.GetHTTPClientAsync();
var result = await client.GetStringAsync(string.Format(ClientConfiguration.Default.SPListURL, "announcements"));
if (result != null)
{
var spData = JsonConvert.DeserializeObject <SPData>(result, new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None
});
int id = 1;
foreach (var val in spData.d.results)
{
items.Add(new NotificationItem {
Id = id, Modified = val.Modified, Title = val.Title, Body = val.Body, IsBodyVisible = false
});
id++;
}
NotificationSource = items;
lstNotifications.ItemsSource = items;
stkNodata.IsVisible = items.Count == 0;
stkCtn.IsVisible = items.Count != 0;
IsBusy = false;
}
}
catch (Exception)
{
Device.BeginInvokeOnMainThread(() =>
{
IsBusy = false;
});
lstNotifications.EndRefresh();
DependencyService.Get <IMessage>().ShortAlert("Unable to retrive notifications.");
}
}
public static async Task<string> GetProfilePicUrl()
{
try
{
string picURL = ClientConfiguration.Default.SPRootURL + "SP.UserProfiles.PeopleManager/GetMyProperties?$select=PictureUrl";
var client = await OAuthHelper.GetHTTPClientAsync();
var response = await client.GetStringAsync(picURL);
if (response != null)
{
var spData = JsonConvert.DeserializeObject<SPData>(response);
return spData.d.PictureUrl;
}
}
catch (Exception ex)
{
}
return "";
}
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<DataContracts.StationInformationSp> GetStationInfoItem(int id)
{
var client = await OAuthHelper.GetHTTPClientAsync();
string url = GetListURL(ReportType.SationInfo) + $"({id})";
try
{
var response = await client.GetStringAsync(url);
var sInfo = JsonConvert.DeserializeObject<StationInformationSpRoot>(response,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
return sInfo.d;
}
catch (Exception ex)
{
}
return null;
}
public static async Task<Dictionary<string, string>> GetStations(bool isOpen = false)
{
MasterInfo mInfo = null;
if (!SPUtility.IsConnected())
{
mInfo = App.DAUtil.GetMasterInfoByName("Stations");
}
else
{
try
{
var client = await OAuthHelper.GetHTTPClientAsync();
string url = GetListURL(ReportType.SationInfo);
if (isOpen)
{
url += "?$filter=Status eq 'Open'";
}
var response = await client.GetStringAsync(url);
if (response != null)
{
mInfo = new MasterInfo { Name = "Stations", content = response };
App.DAUtil.RefreshMasterInfo(mInfo);
}
}
catch (Exception)
{
mInfo = App.DAUtil.GetMasterInfoByName("Stations");
}
}
if (mInfo != null)
{
var stations = JsonConvert.DeserializeObject<SPData>(mInfo.content);
return stations.d.results.Select(x => new { Key = x.Id.ToString(), Value = x.IATA_x0020_Code }).ToDictionary(v => v.Key, v => v.Value);
}
return null;
}
private async Task CompleteTheTask(Result item)
{
IsBusy = true;
var client = await OAuthHelper.GetHTTPClientAsync();
var data = new DataContracts.TaskSp();
data.PercentComplete = 100;
data.__metadata.uri = item.__metadata.uri;
data.__metadata.id = item.__metadata.id;
data.__metadata.etag = item.__metadata.etag;
data.__metadata.type = item.__metadata.type;
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");
contents.Headers.Add("X-HTTP-Method", "MERGE");
client.DefaultRequestHeaders.Add("If-Match", "*");
var postResult = await client.PostAsync(item.__metadata.uri, contents);
if (!postResult.IsSuccessStatusCode)
{
var httpErrorObject = await postResult.Content.ReadAsStringAsync();
}
else
{
IsBusy = false;
Items.Remove(item);
ToggleVisibility();
}
}
public async Task GetFile(DataContracts.Result fileObj)
{
try
{
var client = await OAuthHelper.GetHTTPClientAsync();
string root = ClientConfiguration.Default.ActiveDirectoryResource;
string urlString = Uri.EscapeUriString(root.Remove(root.Length - 1, 1) + fileObj.ServerRelativeUrl);
var myContent = "{'url':'" + urlString + "','isEditLink':false}";
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await client.PostAsync(SPDocumentAnonymousLink, byteContent);
if (response.IsSuccessStatusCode)
{
string str = await response.Content.ReadAsStringAsync();
DocumentAnonymousReponse res = JsonConvert.DeserializeObject <DocumentAnonymousReponse>(str);
Device.OpenUri(new Uri(res.d.CreateAnonymousLink));
Device.BeginInvokeOnMainThread(() =>
{
IsBusy = false;
});
}
}
catch (Exception ex)
{
Device.BeginInvokeOnMainThread(() =>
{
IsBusy = false;
});
DependencyService.Get <IMessage>().ShortAlert("Unable to retrieve file Information");
}
}
private async Task BindStationInfoByIATA(string IATACode)
{
var client = await OAuthHelper.GetHTTPClientAsync();
if (client == null)
{
return;
}
string url = ClientConfiguration.Default.ActiveDirectoryResource + string.Format("SSQServices/_api/Web/lists/GetByTitle('(Ops) Line Station Information')/items?$select=IATA_x0020_Code,Title,City_x0020_Name,Id,Country,Airport_x0020_Type&$filter=IATA_x0020_Code eq '{0}'&Status eq '{1}'", IATACode, "Open");
try
{
var response = await client.GetStringAsync(url);
if (response != null)
{
var spData = JsonConvert.DeserializeObject <SPData>(response,
new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None, NullValueHandling = NullValueHandling.Ignore
});
if (spData.d.results.Count > 0)
{
int id = Convert.ToInt32(spData.d.results[0].Id);
DataContracts.StationInformationSp sInfo = await SPUtility.GetStationInfoItem(id);
ToggleBusy(false);
await Navigation.PushAsync(new StationInformation(sInfo.GetModel()));
}
}
}
catch (Exception ex)
{
}
}
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 void CreateItems <U>(U reportObject) where U : class
{
try
{
ToggleBusy(true);
Device.BeginInvokeOnMainThread(async() =>
{
// StringContent contents = null;
var client = await OAuthHelper.GetHTTPClientAsync();
var data = reportObject;// _viewobject;
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())
{
string url = SPUtility.GetListURL(ReportType.SationInfo);
var postResult = await client.PostAsync(url, contents);
if (postResult.IsSuccessStatusCode)
{
App.DAUtil.Delete(_StationInformation);
lblLoading.Text = "Item created successfully." + Environment.NewLine;
var spData = JsonConvert.DeserializeObject <SPData>(await postResult.Content.ReadAsStringAsync(),
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("Sharepoint error", ex, "Ok");
}
ToggleBusy(false);
}
else
{
SaveOfflineItem(body, ReportType.SationInfo, _attachementView.GetAttachmentInfoAsString());
DependencyService.Get <IMessage>().LongAlert("Item stored in local storage");
ToggleBusy(false);
}
});
}
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);
}
}
