// DEFAULT CONSTRUCTOR
#region Public Methods and Operators
/// <summary>
/// Add data source from <paramref name="datasourceBean"/> to <paramref name="datasourceType"/>
/// </summary>
/// <param name="datasourceBean">
/// The data source SDMX Object.
/// </param>
/// <param name="datasourceType">
/// The data source LINQ2XSD object.
/// </param>
public void AddDatasource(IDataSource datasourceBean, DatasourceType datasourceType)
{
if (datasourceBean.SimpleDatasource)
{
if (datasourceBean.DataUrl != null)
{
datasourceType.SimpleDatasource = datasourceBean.DataUrl;
}
}
else
{
var queryableDatasourceType = new QueryableDatasourceType();
datasourceType.QueryableDatasource = queryableDatasourceType;
if (datasourceBean.DataUrl != null)
{
queryableDatasourceType.DataUrl = datasourceBean.DataUrl;
}
queryableDatasourceType.isRESTDatasource = datasourceBean.RESTDatasource;
queryableDatasourceType.isWebServiceDatasource = datasourceBean.WebServiceDatasource;
if (datasourceBean.WsdlUrl != null)
{
queryableDatasourceType.WSDLUrl = datasourceBean.WsdlUrl;
}
}
}
/*----------------------------------------------------------------------------
* %%Function: SetSourceType
* %%Qualified: AzLog.AzLogFile.SetSourceType
* %%Contact: rlittle
*
* ----------------------------------------------------------------------------*/
public void SetSourceType(DatasourceType dt)
{
if (dt != DatasourceType.AzureBlob)
{
throw new Exception("cannot set datasourcetype on AzLogAzureBlob - must be blob");
}
}
/*----------------------------------------------------------------------------
* %%Function: SetSourceType
* %%Qualified: AzLog.AzLogFile.SetSourceType
* %%Contact: rlittle
*
* ----------------------------------------------------------------------------*/
public void SetSourceType(DatasourceType dt)
{
if (dt != DatasourceType.AzureTable)
{
throw new Exception("cannot set datasourcetype on AzLogAzureTable - must be table");
}
}
public static string TypeToString(DatasourceType st)
{
switch (st)
{
case DatasourceType.AzureTable:
return("AzureTableStorage");
case DatasourceType.AzureBlob:
return("AzureBlobStorage");
case DatasourceType.TextFile:
return("TextFile");
default:
throw new Exception("illegal storage type");
}
}
/* D O O P E N A C C O U N T */
/*----------------------------------------------------------------------------
* %%Function: DoOpenAccount
* %%Qualified: AzLog.AzAddDatasource_Azure.DoOpenAccount
* %%Contact: rlittle
*
* ----------------------------------------------------------------------------*/
private void DoOpenAccount(object sender, EventArgs e)
{
if (m_cbStorageType.SelectedIndex == -1)
{
return;
}
m_lbTables.Items.Clear();
Settings ste = new Settings(_rgsteeAccount, KeyName, "main");
ste.Load();
DatasourceType dt = AzLogDatasourceSupport.TypeFromString(m_cbStorageType.Text);
if (dt == DatasourceType.AzureBlob)
{
AzLogAzureBlob azla = new AzLogAzureBlob();
azla.OpenAccount(
(string)m_cbAccounts.SelectedItem,
AzLogAzureBlob.GetAccountKey(m_sRegRoot, (string)m_cbAccounts.SelectedItem));
foreach (string s in azla.Containers)
{
m_lbTables.Items.Add(s);
}
m_iazlds = azla;
}
else if (dt == DatasourceType.AzureTable)
{
AzLogAzureTable azlt = new AzLogAzureTable();
azlt.OpenAccount(
(string)m_cbAccounts.SelectedItem,
AzLogAzureTable.GetAccountKey(m_sRegRoot, (string)m_cbAccounts.SelectedItem));
foreach (string s in azlt.Tables)
{
m_lbTables.Items.Add(s);
}
m_iazlds = azlt;
}
}
public DbContext(IDbConnection connection, DatasourceType sourceType)
{
Connection = connection;
SourceType = sourceType;
State = DbContextState.Closed;
}
/* O P E N A C C O U N T */
/*----------------------------------------------------------------------------
* %%Function: OpenAccount
* %%Qualified: AzLog.AzLogModel.OpenAccount
* %%Contact: rlittle
*
* Open the given Azure account and populate the list of tables that we
* know about
* ----------------------------------------------------------------------------*/
public void OpenAccount(string sAccountName, string sAccountKey, DatasourceType st)
{
m_plsContainers = PlsNames(sAccountName, sAccountKey, st);
}
public List <string> PlsNames(string sAccountName, string sAccountKey, DatasourceType st)
{
string sConnectionString = String.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}",
sAccountName, sAccountKey);
CloudTableClient ctc = null;
CloudBlobClient cbc = null;
List <string> pls = new List <string>();
try
{
CloudStorageAccount csa = CloudStorageAccount.Parse(sConnectionString);
if (csa == null)
{
return(null);
}
if (st == DatasourceType.AzureTable)
{
ctc = csa.CreateCloudTableClient();
if (ctc == null)
{
return(null);
}
}
else if (st == DatasourceType.AzureBlob)
{
cbc = csa.CreateCloudBlobClient();
if (cbc == null)
{
return(null);
}
}
}
catch
{
return(null);
}
try
{
if (st == DatasourceType.AzureTable)
{
IEnumerable <CloudTable> plct = ctc.ListTables();
foreach (CloudTable ct in plct)
{
pls.Add(ct.Name);
}
}
else if (st == DatasourceType.AzureBlob)
{
IEnumerable <CloudBlobContainer> plcbc = cbc.ListContainers("");
foreach (CloudBlobContainer cbContainer in plcbc)
{
pls.Add(cbContainer.Uri.ToString());
}
}
}
catch
{
return(null);
}
return(pls);
}
/*----------------------------------------------------------------------------
* %%Function: SetSourceType
* %%Qualified: AzLog.AzLogFile.SetSourceType
* %%Contact: rlittle
*
* ----------------------------------------------------------------------------*/
public void SetSourceType(DatasourceType dt)
{
m_dt = dt;
}
public Datasource(DatasourceType dsType)
{
_datasourceType = dsType;
}
/// <summary>
/// The build success response.
/// </summary>
/// <param name="registrations">
/// The registrations.
/// </param>
/// <returns>
/// The <see cref="RegistryInterface"/>.
/// </returns>
public RegistryInterface BuildSuccessResponse(ICollection<IRegistrationObject> registrations)
{
var responseType = new RegistryInterface();
RegistryInterfaceType regInterface = responseType.Content;
var returnType = new QueryRegistrationResponseType();
regInterface.QueryRegistrationResponse = returnType;
V2Helper.Header = regInterface;
if (!ObjectUtil.ValidCollection(registrations))
{
var queryResult = new QueryResultType();
returnType.QueryResult.Add(queryResult);
queryResult.timeSeriesMatch = false;
var statusMessage = new StatusMessageType();
queryResult.StatusMessage = statusMessage;
statusMessage.status = StatusTypeConstants.Warning;
var tt = new TextType();
statusMessage.MessageText.Add(tt);
tt.TypedValue = "No Registrations Match The Query Parameters";
}
else
{
/* foreach */
foreach (IRegistrationObject currentRegistration in registrations)
{
var queryResult0 = new QueryResultType();
returnType.QueryResult.Add(queryResult0);
var statusMessage1 = new StatusMessageType();
queryResult0.StatusMessage = statusMessage1;
this.AddStatus(statusMessage1, null);
queryResult0.timeSeriesMatch = false; // FUNC 1 - when is this true? Also We need MetadataResult
var resultType = new ResultType();
queryResult0.DataResult = resultType;
if (currentRegistration.DataSource != null)
{
IDataSource datasourceBean = currentRegistration.DataSource;
var datasourceType = new DatasourceType();
resultType.Datasource = datasourceType;
if (datasourceBean.SimpleDatasource)
{
datasourceType.SimpleDatasource = datasourceBean.DataUrl;
}
else
{
var queryableDatasource = new QueryableDatasourceType();
datasourceType.QueryableDatasource = queryableDatasource;
queryableDatasource.isRESTDatasource = datasourceBean.RESTDatasource;
queryableDatasource.isWebServiceDatasource = datasourceBean.WebServiceDatasource;
queryableDatasource.DataUrl = datasourceBean.DataUrl;
if (datasourceBean.WsdlUrl != null)
{
queryableDatasource.WSDLUrl = datasourceBean.WsdlUrl;
}
}
}
if (currentRegistration.ProvisionAgreementRef != null)
{
WriteProvisionAgreementRef(currentRegistration.ProvisionAgreementRef, resultType);
}
}
}
return responseType;
}
/// <summary>
/// Build <see cref="RegistrationType"/> from <paramref name="buildFrom"/>.
/// </summary>
/// <param name="buildFrom">
/// The build from.
/// </param>
/// <returns>
/// The <see cref="RegistrationType"/> from <paramref name="buildFrom"/> .
/// </returns>
public RegistrationType Build(IRegistrationObject buildFrom)
{
var builtObj = new RegistrationType();
if (buildFrom.LastUpdated != null)
{
builtObj.LastUpdated = buildFrom.LastUpdated.Date;
}
if (buildFrom.ValidFrom != null)
{
builtObj.ValidFrom = buildFrom.ValidFrom.Date;
}
if (buildFrom.ValidTo != null)
{
builtObj.ValidTo = buildFrom.ValidTo.Date;
}
if (buildFrom.ProvisionAgreementRef != null)
{
ICrossReference provRefBean = buildFrom.ProvisionAgreementRef;
var provRefType = new ProvisionAgreementRefType();
builtObj.ProvisionAgreementRef = provRefType;
if (provRefBean.TargetReference.EnumType == SdmxStructureEnumType.ProvisionAgreement)
{
if (ObjectUtil.ValidString(provRefBean.TargetUrn))
{
provRefType.URN = provRefBean.TargetUrn;
}
}
}
if (buildFrom.DataSource != null)
{
IDataSource datasourceBean = buildFrom.DataSource;
var datasourceType = new DatasourceType();
builtObj.Datasource = datasourceType;
if (datasourceBean.SimpleDatasource)
{
datasourceType.SimpleDatasource = datasourceBean.DataUrl;
}
else
{
var qdst = new QueryableDatasourceType();
datasourceType.QueryableDatasource = qdst;
qdst.isRESTDatasource = datasourceBean.RESTDatasource;
qdst.isWebServiceDatasource = datasourceBean.WebServiceDatasource;
qdst.DataUrl = datasourceBean.DataUrl;
}
}
return builtObj;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="DataSourceCore"/> class.
/// </summary>
/// <param name="datasource">
/// The datasource.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public DataSourceCore(DatasourceType datasource, ISdmxStructure parent)
: base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Datasource), parent)
{
if (datasource.SimpleDatasource != null)
{
this._isSimpleDatasource = true;
this._dataUrl = datasource.SimpleDatasource;
}
else
{
if (datasource.QueryableDatasource != null)
{
this._isSimpleDatasource = false;
this._isRestDatasource = datasource.QueryableDatasource.isRESTDatasource;
this._isWebServiceDatasource = datasource.QueryableDatasource.isWebServiceDatasource;
this._dataUrl = datasource.QueryableDatasource.DataUrl;
this._wsdlUrl = datasource.QueryableDatasource.WSDLUrl;
}
}
this.Validate();
}
/// <summary>
/// The process response.
/// </summary>
/// <param name="returnType">
/// The return type.
/// </param>
/// <param name="registration">
/// The registration.
/// </param>
/// <param name="exception">
/// The exception.
/// </param>
private void ProcessResponse(
SubmitRegistrationResponseType returnType, IRegistrationObject registration, Exception exception)
{
var registrationStatusType = new RegistrationStatusType();
returnType.RegistrationStatus.Add(registrationStatusType);
registrationStatusType.StatusMessage = new StatusMessageType();
this.AddStatus(registrationStatusType.StatusMessage, exception);
if (registration.DataSource != null)
{
var datasourceType = new DatasourceType();
registrationStatusType.Datasource = datasourceType;
this.AddDatasource(registration.DataSource, datasourceType);
}
if (registration.ProvisionAgreementRef != null)
{
ICrossReference provRef = registration.ProvisionAgreementRef;
var provRefType = new ProvisionAgreementRefType();
registrationStatusType.ProvisionAgreementRef = provRefType;
if (provRef.TargetUrn != null)
{
provRefType.URN = provRef.TargetUrn;
}
}
}
/*----------------------------------------------------------------------------
* %%Function: SetSourceType
* %%Qualified: AzLog.AzLogFile.SetSourceType
* %%Contact: rlittle
*
* ----------------------------------------------------------------------------*/
public void SetSourceType(DatasourceType dt)
{
throw new Exception("cannot set datasourcetype on LogFile - must be text");
}
