// 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"); }