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 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 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;
}
public CollectionDataItem(ServiceInfo service, Table table)
: base(GetUniqueId(service.Name, table.ActualName), table.ActualName, GetCollectionSummary(table), null, null)
{
this.Table = table;
}
public ErrorDataItem(ServiceInfo service, XElement element)
: base(GetUniqueId(service.Name, element.Name), element.Name.ToString(), "Unable to load service metadata", null, GetErrorDescription(element))
{
}
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;
}
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 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;
}
public void AddService(ServiceInfo serviceInfo)
{
serviceInfo.Index = this.Services.Count;
this.Services.Add(serviceInfo);
}
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 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> 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);
}
