public void UpdateService(string serviceName, ServiceInfo serviceInfo) { var originalService = this.Services.Single(x => x.Name == serviceName); originalService.Name = serviceInfo.Name; originalService.Url = serviceInfo.Url; originalService.Description = serviceInfo.Description; originalService.Logo = serviceInfo.Logo; originalService.MetadataCache = serviceInfo.MetadataCache; originalService.CacheUpdated = serviceInfo.CacheUpdated; }
public void DeleteService(ServiceInfo serviceInfo) { var originalService = this.Services.SingleOrDefault(x => x.Name == serviceInfo.Name); if (originalService != null) { this.Services.Remove(originalService); } for (int index = 0; index < this.Services.Count; index++) { this.Services[index].Index = index; } }
private async void AddServiceAsync() { var serviceInfo = new ServiceInfo() { Name = this.serviceName.Text, Url = this.serviceUrl.Text, Description = this.serviceDescription.Text, Logo = "Custom", }; await DataSource.Instance.AddServiceDataItemAsync(serviceInfo); }
public PropertyDataItem(ServiceInfo service, Table table, Column column) : base(GetUniqueId(service.Name, table.ActualName, column.ActualName), column.ActualName, GetColumnSummary(column, table.GetKeyNames()), null, null) { }
public async static Task<bool> SaveServiceMetadataCacheAsync(ServiceInfo serviceInfo) { return await SaveSettingToFileAsync(serviceInfo.MetadataCacheFilename, serviceInfo.MetadataCache); }
private static string GetImagePath(ServiceInfo service) { return "Samples/" + (string.IsNullOrEmpty(service.Logo) ? service.Name : service.Logo) + ".png"; }
public void AddService(ServiceInfo serviceInfo) { serviceInfo.Index = this.Services.Count; this.Services.Add(serviceInfo); }
public async Task<bool> UpdateServiceDataItemAsync(ServiceDataItem serviceItem, ServiceInfo serviceInfo) { var originalTitle = serviceItem.Title; serviceItem.Title = serviceInfo.Name; serviceItem.Subtitle = serviceInfo.Url; serviceItem.Description = serviceInfo.Description; bool ok = await RefreshMetadataCacheAsync(serviceInfo); if (ok) { RefreshServiceCollectionsFromMetadataCache(serviceItem, serviceInfo); App.AppData.UpdateService(originalTitle, serviceInfo); ok = await App.AppData.SaveServicesAsync(); } return ok; }
public ErrorDataItem(ServiceInfo service, XElement element) : base(GetUniqueId(service.Name, element.Name), element.Name.ToString(), "Unable to load service metadata", null, GetErrorDescription(element)) { }
public CollectionDataItem(ServiceInfo service, Table table) : base(GetUniqueId(service.Name, table.ActualName), table.ActualName, GetCollectionSummary(table), null, null) { this.Table = table; }
private ErrorDataItem CreateErrorDataItem(ServiceInfo service, XElement element) { var item = new ErrorDataItem(service, element); return(item); }
private void RefreshServiceCollectionsFromMetadataCache(ServiceDataItem item, ServiceInfo service) { item.Elements.Clear(); if (!string.IsNullOrEmpty(service.MetadataCache)) { var element = XElement.Parse(service.MetadataCache); if (element.Name == "Error") { var errorItem = CreateErrorDataItem(service, element); item.Elements.Add(errorItem); } else { var schema = ODataClient.ParseSchemaString(service.MetadataCache); foreach (var table in schema.Tables) { var collectionItem = CreateCollectionDataItem(service, table); item.Elements.Add(collectionItem); } } } }
public PropertyDataItem(ServiceInfo service, Table table, Association association) : base(GetUniqueId(service.Name, table.ActualName, association.ActualName), association.ActualName, GetAssociationSummary(association), null, null) { }
public async Task<bool> RemoveServiceDataItemAsync(ServiceDataItem serviceItem) { _rootItem.Elements.Remove(serviceItem); var serviceInfo = new ServiceInfo() { Name = serviceItem.Title }; App.AppData.DeleteService(serviceInfo); bool ok = await App.AppData.SaveServicesAsync(); return ok; }
public async static Task <bool> SaveServiceMetadataCacheAsync(ServiceInfo serviceInfo) { return(await SaveSettingToFileAsync(serviceInfo.MetadataCacheFilename, serviceInfo.MetadataCache)); }
private ServiceDataItem CreateServiceDataItem(ServiceInfo service) { var item = new ServiceDataItem(service); RefreshServiceCollectionsFromMetadataCache(item, service); return item; }
public ServiceDataItem(ServiceInfo service) : base(GetUniqueId(service.Name), service.Name, service.Url, GetImagePath(service), service.Description) { _metadataCache = service.MetadataCache; }
public static string FormatServiceInfo(ServiceInfo serviceInfo) { var element = new XElement("Service"); element.Add(new XElement("Name", serviceInfo.Name)); element.Add(new XElement("Url", serviceInfo.Url)); element.Add(new XElement("Description", serviceInfo.Description)); element.Add(new XElement("Logo", serviceInfo.Logo)); element.Add(new XElement("CacheUpdated", serviceInfo.CacheUpdated)); element.Add(new XElement("Index", serviceInfo.Index)); return element.ToString(); }
private CollectionDataItem CreateCollectionDataItem(ServiceInfo service, Table table) { var item = new CollectionDataItem(service, table); foreach (var column in table.Columns) { item.Elements.Add(new PropertyDataItem(service, table, column)); } foreach (var association in table.Associations) { item.Elements.Add(new PropertyDataItem(service, table, association)); } return item; }
private ErrorDataItem CreateErrorDataItem(ServiceInfo service, XElement element) { var item = new ErrorDataItem(service, element); return item; }
private async Task<bool> RefreshMetadataCacheAsync(ServiceInfo service) { var metadata = await LoadServiceMetadataAsync(service); service.MetadataCache = metadata; service.CacheUpdated = DateTimeOffset.UtcNow; var serviceItem = GetItem(service.Name) as ServiceDataItem; if (serviceItem != null) { serviceItem.MetadataCache = service.MetadataCache; } await AppData.SaveServiceMetadataCacheAsync(service); return true; }
private async Task<string> LoadServiceMetadataAsync(ServiceInfo service) { var task = Task<string>.Factory.StartNew(() => { try { return ODataClient.GetSchemaAsString(service.Url); } catch (Exception exception) { var element = new XElement("Error"); element.Add(new XElement("Message", exception.Message)); return element.ToString(); } }); return await task; }
public async Task<bool> AddServiceDataItemAsync(ServiceInfo serviceInfo) { var serviceItem = this.CreateServiceDataItem(serviceInfo); _rootItem.Elements.Add(serviceItem); bool ok = await RefreshMetadataCacheAsync(serviceInfo); if (ok) { RefreshServiceCollectionsFromMetadataCache(serviceItem, serviceInfo); App.AppData.AddService(serviceInfo); ok = await App.AppData.SaveServicesAsync(); } return ok; }
private async void UpdateServiceAsync() { var serviceInfo = new ServiceInfo() { Name = this.serviceName.Text, Url = this.serviceUrl.Text, Description = this.serviceDescription.Text, Logo = Path.GetFileNameWithoutExtension(_editedItem.ImagePath), }; serviceInfo.MetadataCache = null; await DataSource.Instance.UpdateServiceDataItemAsync(_editedItem, serviceInfo); }
public async Task <bool> UpdateServiceDataItemAsync(ServiceDataItem serviceItem, ServiceInfo serviceInfo) { var originalTitle = serviceItem.Title; serviceItem.Title = serviceInfo.Name; serviceItem.Subtitle = serviceInfo.Url; serviceItem.Description = serviceInfo.Description; bool ok = await RefreshMetadataCacheAsync(serviceInfo); if (ok) { RefreshServiceCollectionsFromMetadataCache(serviceItem, serviceInfo); App.AppData.UpdateService(originalTitle, serviceInfo); ok = await App.AppData.SaveServicesAsync(); } return(ok); }