public UploadParam(string fileName)
{
var file = new FileInfo(fileName);
var ext = file.Extension.ToLower();
Directory = file.DirectoryName;
Name = Path.GetFileNameWithoutExtension(file.Name);
Progress = 0;
IsPlanned = false;
switch (ext)
{
case ".cfg":
ExtractSourceDataTypeFromConfigFile(fileName);
break;
case ".csv":
goto default;
case ".kml":
Type = SourceDataType.Kml;
_dataLoaderParams = Kml.KmlToTablesDataLoaderParams.FromFile(this);
break;
default:
Type = SourceDataType.Csv;
_dataLoaderParams = CsvToTablesDataLoaderParams.FromFile(this);
break;
}
}
private static void CheckMetadataChanges(string metadataSet, string entitySet, string entityKind, Entity entity,
DataLoaderParams Params, MetadataKind metadataKind)
{
var context = new TableContext(s_account.TableEndpoint.ToString(), s_account.Credentials, Params)
{
RetryPolicy =
RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount,
RetryPolicies.DefaultClientBackoff)
};
string query = string.Format(s_metadataEntityQueryTemplate, metadataSet, entitySet, entityKind);
List <TableEntity> results = context.Execute <TableEntity>(new Uri(query, UriKind.Relative)).ToList();
if (results.Count == 1)
{
var exceprionColumns = new[]
{
DataLoaderConstants.PropNameEntityId,
DataLoaderConstants.PropNameLastUpdateDate
};
string differences = results[0].FindDifferences(entity, exceprionColumns);
if (differences != null)
{
throw new MetadataChangedException(entitySet, differences);
}
}
else if (results.Count > 1)
{
throw new DuplicateEntityException(query);
}
else if (results.Count == 0)
{
throw new MetadataNotFoundException(entitySet, metadataKind);
}
}
public void VerifyConfiguration()
{
try
{
string path = Path.Combine(Directory, Name + ".cfg");
var serializer = new XmlSerializer(DataLoaderParams.GetType());
if (File.Exists(path))
{
using (FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read))
{
var parameters = (DataLoaderParams)serializer.Deserialize(stream);
ConfigurationState = parameters.TableMetadataEntity.IsEmpty ? VerifyPlanned(parameters) : VerifyPublished(parameters);
}
}
else
{
ConfigurationState = IsPlanned ? ConfigurationState.Ready : ConfigurationState.Incomplete;
}
}
catch (Exception)
{
ConfigurationState = ConfigurationState.Incomplete;
}
}
public TableContext(string baseAddress, StorageCredentials credentials, DataLoaderParams _params)
: base(baseAddress, credentials)
{
var pars = _params as CsvToTablesDataLoaderParams;
if (pars != null)
{
this._params = pars.ProcessorParams;
}
WritingEntity += OnWritingEntity;
ReadingEntity += TableContext_ReadingEntity;
}
public ProcessorParamsControlViewModel(DataLoaderParams parameters)
{
#region fill timezones
var timeZones = TimeZoneInfo.GetSystemTimeZones();
_timeZones = timeZones.OrderBy(x => x.BaseUtcOffset.Hours).Select(x => x.DisplayName).ToArray();
#endregion fill timezones
_processorParameters = parameters.ProcessorParams;
if (parameters.ProducerParams != null)
_datasetColumns = (new[] { "New.Guid" }).Union(parameters.ProducerParams.PropertyToTypeMap.Mappings.Select(x => x.Name));
}
private static ConfigurationState VerifyPlanned(DataLoaderParams parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (parameters.TableMetadataEntity == null)
{
throw new ArgumentException();
}
if (!parameters.TableMetadataEntity.IsEmpty)
{
throw new ArgumentException();
}
return(VerifyTableMetadataEntity(parameters));
}
public void RefreshDataLoaderParams()
{
switch (_type)
{
case SourceDataType.Csv:
goto default;
case SourceDataType.DbfAndKml:
//_dataLoaderParams = DbaseKml.DbaseKmlToTablesDataLoaderParams.FromFile(this);
break;
case SourceDataType.Kml:
_dataLoaderParams = Kml.KmlToTablesDataLoaderParams.FromFile(this);
break;
default:
_dataLoaderParams = CsvToTablesDataLoaderParams.FromFile(this);
break;
}
}
public MetadataWindowViewModel(UploadParam uploadParam)
{
if (uploadParam == null)
return;
uploadParam.RefreshDataLoaderParams();
_uploadParam = uploadParam;
//Assigning ProducerControlView
switch (uploadParam.Type)
{
case SourceDataType.Csv:
_dataLoaderParams = uploadParam.DataLoaderParams;
if (!_uploadParam.IsPlanned)
{
_producerParams = new CsvProducerControlView { DataContext = new CsvProducerControlViewModel(_dataLoaderParams) };
}
break;
case SourceDataType.DbfAndKml:
_dataLoaderParams = uploadParam.DataLoaderParams;
_producerParams = new UserControl { IsEnabled = false };
break;
case SourceDataType.Kml:
_dataLoaderParams = uploadParam.DataLoaderParams;
_producerParams = new CsvProducerControlView { DataContext = new CsvProducerControlViewModel(_dataLoaderParams) };
break;
default:
throw new InvalidOperationException("Unknown upload parameter type.");
}
_processorParams = new ProcessorParamsControlView { DataContext = new ProcessorParamsControlViewModel(_dataLoaderParams) };
_metadata = new MetadataControlView { DataContext = new MatadataControlViewModel(_dataLoaderParams) };
_columnsMetadata = new ColumnsMetadataControlView { DataContext = new ColumnsMetadataWindowViewModel(_dataLoaderParams) };
_dataLoaderParams.TableMetadataEntity.IsEmpty = uploadParam.IsPlanned;
}
private static ConfigurationState VerifyTableMetadataEntity(DataLoaderParams parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (parameters.TableMetadataEntity == null)
{
throw new ArgumentException();
}
var required = new[]
{
parameters.TableMetadataEntity.Name, parameters.TableMetadataEntity.EntitySet,
parameters.TableMetadataEntity.Source, parameters.TableMetadataEntity.Category
};
if (required.Any(s => string.IsNullOrEmpty(s)))
{
return(ConfigurationState.Incomplete);
}
foreach (PropertyInfo propertyInfo in typeof(TableMetadataEntity).GetProperties())
{
object val = propertyInfo.GetValue(parameters.TableMetadataEntity, null);
if (val == null)
{
return(ConfigurationState.Acceptable);
}
var str = val as string;
if (str != null && string.IsNullOrEmpty(str))
{
return(ConfigurationState.Acceptable);
}
}
return(ConfigurationState.Ready);
}
public UploadParam(SourceDataType type)
{
Type = type;
IsPlanned = true;
switch (type)
{
case SourceDataType.Csv:
_dataLoaderParams = CsvToTablesDataLoaderParams.FromFile(this);
break;
case SourceDataType.DbfAndKml:
break;
case SourceDataType.Kml:
_dataLoaderParams = Kml.KmlToTablesDataLoaderParams.FromFile(this);
break;
default:
throw new InvalidOperationException();
}
}
private static void DeleteRdfMetadata(string metadataSet, string entitySet,
DataLoaderParams parameters)
{
var context = new TableContext(s_account.TableEndpoint.ToString(), s_account.Credentials, parameters)
{
RetryPolicy =
RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount,
RetryPolicies.DefaultClientBackoff)
};
string query = string.Format(s_metadataRdfQueryTemplate, metadataSet, entitySet);
List <TableEntity> results = context.Execute <TableEntity>(new Uri(query, UriKind.Relative)).ToList();
if (results.Count > 0)
{
foreach (TableEntity i in results)
{
context.DeleteObject(i);
context.SaveChanges();
}
}
}
public CsvProducerControlViewModel(DataLoaderParams parameters)
{
_datasetColumns = parameters.ProducerParams;
_entityProperties = new PropertyToTypeMap();
if (_datasetColumns.PlacemarkParams == null || _datasetColumns.PlacemarkParams.NameProperties == null)
{
_datasetColumns.PlacemarkParams = null;
return;
}
foreach (var property in _datasetColumns.PropertyToTypeMap.Mappings)
{
for (int i = 0; i < _datasetColumns.PlacemarkParams.NameProperties.Length; i++)
{
string nameProperty = _datasetColumns.PlacemarkParams.NameProperties[i];
if (nameProperty != null && nameProperty.ToLower() == property.Name.ToLower())
property.IndexInName = "{" + i + "}";
}
}
}
private static void DeleteMetadata(string metadataSet, string entitySet, string entityKind,
DataLoaderParams parameters)
{
var context = new TableContext(s_account.TableEndpoint.ToString(), s_account.Credentials, parameters)
{
RetryPolicy =
RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount,
RetryPolicies.DefaultClientBackoff)
};
string query = string.Format(s_metadataEntityQueryTemplate, metadataSet, entitySet, entityKind);
List <TableEntity> results = context.Execute <TableEntity>(new Uri(query, UriKind.Relative)).ToList();
if (results.Count == 1)
{
context.DeleteObject(results.First());
context.SaveChanges();
}
else if (results.Count > 1)
{
throw new DuplicateEntityException(query);
}
}
private static void CheckAndUpdateMetadataLastUpdateDate(string metadataSet, string entitySet, string entityKind,
DateTime lastUpdateDate, DataLoaderParams Params)
{
var context = new TableContext(s_account.TableEndpoint.ToString(), s_account.Credentials, Params)
{
RetryPolicy =
RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount,
RetryPolicies.DefaultClientBackoff)
};
string query = string.Format(s_metadataEntityQueryTemplate, metadataSet, entitySet, entityKind);
List<TableEntity> results = context.Execute<TableEntity>(new Uri(query, UriKind.Relative)).ToList();
if (results.Count == 1)
{
DateTime oldLastUpdateDate = new TableMetadataEntity(results[0]).LastUpdateDate;
if (oldLastUpdateDate > lastUpdateDate)
throw new MetadataOutdatedException(oldLastUpdateDate, lastUpdateDate);
results[0].UpdateProperty(DataLoaderConstants.PropNameLastUpdateDate, lastUpdateDate);
context.UpdateObject(results[0]);
context.SaveChanges();
}
else if (results.Count > 1)
{
throw new DuplicateEntityException(query);
}
}
public MatadataControlViewModel(DataLoaderParams parameters)
{
_instance = parameters.TableMetadataEntity;
EntitySet = _instance.EntitySet;
}
public abstract IEnumerable<Entity> GetEntitiesEnumerator(OnContinueExceptionCallback exceptionNotifier, DataLoaderParams Params);
public DataLoader(DataLoaderParams parameters, EntityProducer producer, EntityProcessor processor)
{
Params = parameters;
Producer = producer;
Processor = processor;
}
private static void CheckAndUpdateMetadataLastUpdateDate(string metadataSet, string entitySet, string entityKind,
DateTime lastUpdateDate, DataLoaderParams Params)
{
var context = new TableContext(s_account.TableEndpoint.ToString(), s_account.Credentials, Params)
{
RetryPolicy =
RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount,
RetryPolicies.DefaultClientBackoff)
};
string query = string.Format(s_metadataEntityQueryTemplate, metadataSet, entitySet, entityKind);
List <TableEntity> results = context.Execute <TableEntity>(new Uri(query, UriKind.Relative)).ToList();
if (results.Count == 1)
{
DateTime oldLastUpdateDate = new TableMetadataEntity(results[0]).LastUpdateDate;
if (oldLastUpdateDate > lastUpdateDate)
{
throw new MetadataOutdatedException(oldLastUpdateDate, lastUpdateDate);
}
results[0].UpdateProperty(DataLoaderConstants.PropNameLastUpdateDate, lastUpdateDate);
context.UpdateObject(results[0]);
context.SaveChanges();
}
else if (results.Count > 1)
{
throw new DuplicateEntityException(query);
}
}
public ColumnsMetadataWindowViewModel(DataLoaderParams parameters)
{
_columnsMetadata = parameters.TableColumnsMetadata ?? new TableColumnsMetadata();
_entityColumnsMetadata = new PropertyToTypeColumnsMetadataMap();
}
private static void DeleteRdfMetadata(string metadataSet, string entitySet,
DataLoaderParams parameters)
{
var context = new TableContext(s_account.TableEndpoint.ToString(), s_account.Credentials, parameters)
{
RetryPolicy =
RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount,
RetryPolicies.DefaultClientBackoff)
};
string query = string.Format(s_metadataRdfQueryTemplate, metadataSet, entitySet);
List<TableEntity> results = context.Execute<TableEntity>(new Uri(query, UriKind.Relative)).ToList();
if (results.Count > 0)
{
foreach (TableEntity i in results)
{
context.DeleteObject(i);
context.SaveChanges();
}
}
}
public DataLoader(DataLoaderParams parameters, EntityProducer producer, EntityProcessor processor)
{
Params = parameters;
Producer = producer;
Processor = processor;
}
private static void CheckMetadataChanges(string metadataSet, string entitySet, string entityKind, Entity entity,
DataLoaderParams Params, MetadataKind metadataKind)
{
var context = new TableContext(s_account.TableEndpoint.ToString(), s_account.Credentials, Params)
{
RetryPolicy =
RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount,
RetryPolicies.DefaultClientBackoff)
};
string query = string.Format(s_metadataEntityQueryTemplate, metadataSet, entitySet, entityKind);
List<TableEntity> results = context.Execute<TableEntity>(new Uri(query, UriKind.Relative)).ToList();
if (results.Count == 1)
{
var exceprionColumns = new[]
{
DataLoaderConstants.PropNameEntityId,
DataLoaderConstants.PropNameLastUpdateDate
};
string differences = results[0].FindDifferences(entity, exceprionColumns);
if (differences != null)
throw new MetadataChangedException(entitySet, differences);
}
else if (results.Count > 1)
{
throw new DuplicateEntityException(query);
}
else if (results.Count == 0)
{
throw new MetadataNotFoundException(entitySet, metadataKind);
}
}
private static void DeleteMetadata(string metadataSet, string entitySet, string entityKind,
DataLoaderParams parameters)
{
var context = new TableContext(s_account.TableEndpoint.ToString(), s_account.Credentials, parameters)
{
RetryPolicy =
RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount,
RetryPolicies.DefaultClientBackoff)
};
string query = string.Format(s_metadataEntityQueryTemplate, metadataSet, entitySet, entityKind);
List<TableEntity> results = context.Execute<TableEntity>(new Uri(query, UriKind.Relative)).ToList();
if (results.Count == 1)
{
context.DeleteObject(results.First());
context.SaveChanges();
}
else if (results.Count > 1)
{
throw new DuplicateEntityException(query);
}
}
public TableDataLoader(DataLoaderParams parameters, EntityProducer producer, EntityProcessor processor,
TableOverwriteMode overwriteMode)
: base(parameters, producer, processor)
{
this.overwriteMode = overwriteMode;
}
public TableDataLoader(DataLoaderParams parameters, EntityProducer producer, EntityProcessor processor,
TableOverwriteMode overwriteMode)
: base(parameters, producer, processor)
{
this.overwriteMode = overwriteMode;
}
public abstract IEnumerable <Entity> GetEntitiesEnumerator(OnContinueExceptionCallback exceptionNotifier, DataLoaderParams Params);
