Example #1
0
        public virtual string GetSiteInfo(string SiteNumber, String authToken)
        {
            SiteInfoResponseType aSite = GetSiteInfoObject(SiteNumber, null);
            string xml = WSUtils.ConvertToXml(aSite, typeof(SiteInfoResponseType));

            return(xml);
        }
            public SiteInfoResponseType GetSites(string[] locationParameters, Boolean includeSeries)
            {
                locationParameters = WSUtils.removeEmptyStrings(locationParameters);

                List <locationParam> siteCodes = new List <locationParam>(locationParameters.Length);

                foreach (String s in locationParameters)
                {
                    locationParam lp = new locationParam(s);
                    siteCodes.Add(lp);
                }
                SiteInfoType[]       sites  = ODSiteInfo.GetSitesByLocationParameters(siteCodes.ToArray());
                SiteInfoResponseType result = CreateSitesResponse(sites, includeSeries);

                if (locationParameters.Length == 0)
                {
                    result.queryInfo = CuahsiBuilder.CreateQueryInfoType("GetSites");
                    NoteType note = CuahsiBuilder.createNote("ALL Sites(empty request)");
                    result.queryInfo.note = CuahsiBuilder.addNote(null, note);
                }
                else
                {
                    result.queryInfo = CuahsiBuilder.CreateQueryInfoType("GetSites", locationParameters, null, null, null, null);
                }
                return(result);
            }
Example #3
0
            public override string GetVariableInfo(string variable, String authToken)
            {
                VariablesResponseTypeGeneric aVType = GetVariableInfoObject(variable, null);
                string xml = WSUtils.ConvertToXml(aVType, typeof(xsd.VariablesResponse));

                return(xml);
            }
Example #4
0
        public virtual string GetValues(string locationParam, string VariableCode, string StartDate, string EndDate,
                                        String authToken)
        {
            TimeSeriesResponseType aSite = GetValuesObject(locationParam, VariableCode, StartDate, EndDate, null);

            return(WSUtils.ConvertToXml(aSite, typeof(TimeSeriesResponseType)));
        }
Example #5
0
            public override string GetSiteInfo(string site, String authToken)
            {
                SiteInfoResponseTypeGeneric aSite = GetSiteInfoObject(site, null);
                string xml = WSUtils.ConvertToXml(aSite, typeof(xsd.SiteInfoResponse));

                return(xml);
            }
Example #6
0
        public string GetVariableInfo(string Variable, String authToken)
        {
            VariablesResponseType aVType = GetVariableInfoObject(Variable, null);
            string xml = WSUtils.ConvertToXml(aVType, typeof(VariablesResponseType));

            return(xml);
        }
Example #7
0
        public string GetSites(string[] SiteNumbers, String authToken)
        {
            SiteInfoResponseType aSite = GetSitesObject(SiteNumbers, null);
            string xml = WSUtils.ConvertToXml(aSite, typeof(SiteInfoResponseType));

            return(xml);
        }
Example #8
0
        public void SignRequest(ref RestRequest m, RestClient client)
        {
            if (LoginState == LoginState.LoggedOut && !Login())
            {
                throw new Exception("You must be logged into AutoCAD to use the package manager.");
            }

            var url = client.BaseUrl + m.Resource;

            HttpMethod method = HttpMethod.Get;

            if (m.Method == Method.PUT)
            {
                method = HttpMethod.Put;
            }
            else if (m.Method == Method.POST)
            {
                method = HttpMethod.Post;
            }

            var paramList = new List <WebServiceRequestParam>();

            foreach (var p in m.Parameters)
            {
                if (p.Value is string value)
                {
                    paramList.Add(new WebServiceRequestParam(p.Name, UrlEncodeRelaxed(value)));
                }
            }

            // pass empty consumer key/secret to use AutoCAD oauth.
            var auth = WSUtils.SignRequest(url, paramList.ToArray(), method, WebServiceRequestParsingMode.ParseForRequestContent, string.Empty, string.Empty);

            m.Resource = m.Resource + "?" + auth;
        }
Example #9
0
        public bool Login()
        {
            bool result = false;

            SyncContext.Send((_) => result = WSUtils.Login(), null);
            LoginStateChanged?.Invoke(result ? LoginState.LoggedIn : LoginState.LoggedOut);

            return(result);
        }
        public SiteInfoResponseType GetSites(string[] locationParameters)
        {
            XmlDocument XMLResponse = new XmlDocument();

            locationParameters = WSUtils.removeEmptyStrings(locationParameters);
            //string[] siteCodes = Array.ConvertAll(locationParameters, new Converter<string, string>(locationParam.getSiteCode));
            List <locationParam> siteCodes = new List <locationParam>(locationParameters.Length);

            foreach (String s in locationParameters)
            {
                locationParam lp = new locationParam(s);
                siteCodes.Add(lp);
            }

            SiteInfoResponseType result = CreateSitesResponse(siteCodes.ToArray());


            return(result);
        }
Example #11
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="query"></param>
        /// <param name="operation"></param>
        private ISdmxObjects WSExecute(ArtefactIdentity artIdentity, WSConstants.wsOperation operation, bool stub, bool withLike)
        {
            XmlDocument xDomOutput = new XmlDocument();

            WSUtils wsUtils = new WSUtils();

            ISdmxObjects SdmxObject, FilteredSdmxObject;

            FilteredSdmxObject = new SdmxObjectsImpl();

            try
            {
                // File di appoggio per la creazione del xDom
                string OutputFilePath = HttpContext.Current.Server.MapPath("OutputFiles" + "\\" + HttpContext.Current.Session.SessionID + ".xml");

                WsConfigurationSettings wsSettings = null;

                if (operation == WSConstants.wsOperation.GetDataStructureWithRef)
                {
                    wsSettings = wsUtils.GetSettings(WSConstants.wsOperation.GetDataStructure.ToString());
                }
                else
                {
                    wsSettings = wsUtils.GetSettings(FindException(operation));
                }

                XmlDocument xDom = new XmlDocument();

                // Carico il template
                xDom.Load(getTemplate(operation));

                // Imposto ID,Agency e Version
                if (!withLike && artIdentity != null)
                    SetKey(ref xDom, artIdentity);
                else
                    RemoveFilter(xDom);

                if (stub)
                    SetStub(ref xDom);

                FlyCallWS.Streaming.CallWS objWS = new FlyCallWS.Streaming.CallWS(OutputFilePath, WSConstants.MaxOutputFileLength);

                xDomOutput.InnerXml = objWS.SendSOAPQuery(xDom, wsSettings);

                File.Delete(OutputFilePath);

                SdmxObject = LoadSDMXObject(xDomOutput);

                if (withLike && !IsNullOrEmptyArtefactIdentity(artIdentity))
                    switch (operation)
                    {
                        case WSConstants.wsOperation.GetAgencyScheme:
                            var filteredAgency = SdmxObject.AgenciesSchemes.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.Base.IAgencyScheme ag in filteredAgency)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && ag.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddAgencyScheme(ag);
                            }
                            break;
                        case WSConstants.wsOperation.GetCategorisation:
                            var filteredCat = SdmxObject.Categorisations.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.CategoryScheme.ICategorisationObject cat in filteredCat)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && cat.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddCategorisation(cat);
                            }
                            break;
                        case WSConstants.wsOperation.GetCategoryScheme:
                            var filteredCS = SdmxObject.CategorySchemes.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.CategoryScheme.ICategorySchemeObject cat in filteredCS)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && cat.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddCategoryScheme(cat);
                            }
                            break;
                        case WSConstants.wsOperation.GetCodelist:
                            var filteredCL = SdmxObject.Codelists.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.Codelist.ICodelistObject cl in filteredCL)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && cl.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddCodelist(cl);
                            }
                            break;
                        case WSConstants.wsOperation.GetConceptScheme:
                            var filteredCoS = SdmxObject.ConceptSchemes.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.ConceptScheme.IConceptSchemeObject x in filteredCoS)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddConceptScheme(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetDataflow:
                            var filteredDF = SdmxObject.Dataflows.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.DataStructure.IDataflowObject x in filteredDF)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddDataflow(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetStructureSet:
                            var filteredSS = SdmxObject.StructureSets.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.Mapping.IStructureSetObject x in filteredSS)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddStructureSet(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetContentConstraint:
                            var filteredCC = SdmxObject.ContentConstraintObjects.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.Registry.IContentConstraintObject x in filteredCC)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddContentConstraintObject(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetOrganisationUnitScheme:
                            var filteredOU = SdmxObject.OrganisationUnitSchemes.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.Base.IOrganisationUnitSchemeObject x in filteredOU)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddOrganisationUnitScheme(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetDataConsumerScheme:
                            var filteredDC = SdmxObject.DataConsumerSchemes.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.Base.IDataConsumerScheme x in filteredDC)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddDataConsumerScheme(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetDataProviderScheme:
                            var filteredDP = SdmxObject.DataProviderSchemes.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.Base.IDataProviderScheme x in filteredDP)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddDataProviderScheme(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetDataStructureWithRef:
                        case WSConstants.wsOperation.GetDataStructure:
                            var filteredDSD = SdmxObject.DataStructures.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.DataStructure.IDataStructureObject x in filteredDSD)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddDataStructure(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetHierarchicalCodelist:
                            var filteredHcl = SdmxObject.HierarchicalCodelists.Where(i => i.Id.ToUpper().Contains(artIdentity.ID.ToUpper()) && i.AgencyId.ToUpper().Contains(artIdentity.Agency.ToUpper()) && i.Version.ToUpper().Contains(artIdentity.Version.ToUpper()));
                            foreach (Org.Sdmxsource.Sdmx.Api.Model.Objects.Codelist.IHierarchicalCodelistObject x in filteredHcl)
                            {
                                if ((artIdentity.IsFinal == null || !(bool)artIdentity.IsFinal) || (bool)artIdentity.IsFinal && x.IsFinal.IsTrue)
                                    FilteredSdmxObject.AddHierarchicalCodelist(x);
                            }
                            break;
                        case WSConstants.wsOperation.GetStructures:
                            break;
                        default:
                            FilteredSdmxObject = SdmxObject;
                            break;
                    }
                else
                    FilteredSdmxObject = SdmxObject;

                return FilteredSdmxObject;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        protected void btnConfirmImport_Click(object sender, EventArgs e)
        {
            bool oneRowIsOk = false;
            GridViewRowCollection rows = gridView.Rows;

            foreach (GridViewRow row in rows)
            {
                if (((CheckBox)row.Cells[4].Controls[1]).Checked)
                {
                    oneRowIsOk = true;
                    break;
                }
            }

            if (oneRowIsOk)
            {
                WSModel wsModel = new WSModel();
                XmlDocument xDocStructure = new XmlDocument();
                XmlDocument xDocMessage = new XmlDocument();
                XmlDocument xRet;
                WSUtils utils = new WSUtils();
                List<ImportedItem> myItems = Session[IMPORTED_ITEMS_STRING] as List<ImportedItem>;
                ISdmxObjects sdmxObjects = (ISdmxObjects)Session[IMPORTED_SDMX_OBJECT];
                ISdmxObjects newSdmxObjects = new SdmxObjectsImpl();
                List<ImportedItem> reportItems = new List<ImportedItem>();
                string objectsSummary = string.Empty;

                foreach (GridViewRow row in gridView.Rows)
                {
                    string currentId = ((Label)row.Cells[0].Controls[1]).Text;
                    string currentAgency = ((Label)row.Cells[1].Controls[1]).Text;
                    string currentVersion = ((Label)row.Cells[2].Controls[1]).Text;
                    ImportedItem myCurrentItem = myItems.Find(item => item.ID.Equals(currentId) && item.Agency.Equals(currentAgency) && item.Version.Equals(currentVersion));

                    if (((CheckBox)row.Cells[4].Controls[1]).Checked)
                    {
                        switch (myCurrentItem._type)
                        {
                            case "CODELIST":
                                ICodelistObject tmpCodeList = sdmxObjects.Codelists.First(codelist => codelist.Id.Equals(currentId) && codelist.AgencyId.Equals(currentAgency) && codelist.Version.Equals(currentVersion));
                                newSdmxObjects.AddCodelist(tmpCodeList);
                                objectsSummary += string.Format(Resources.Messages.msg_codelist_imported, tmpCodeList.Id, tmpCodeList.AgencyId, tmpCodeList.Version);
                                break;
                            case "CONCEPT_SCHEME":
                                IConceptSchemeObject tmpConceptScheme = sdmxObjects.ConceptSchemes.First(conceptScheme => conceptScheme.Id.Equals(currentId) && conceptScheme.AgencyId.Equals(currentAgency) && conceptScheme.Version.Equals(currentVersion));
                                newSdmxObjects.AddConceptScheme(tmpConceptScheme);
                                objectsSummary += string.Format(Resources.Messages.msg_concept_scheme_imported, tmpConceptScheme.Id, tmpConceptScheme.AgencyId, tmpConceptScheme.Version);
                                break;
                            case "CATEGORY_SCHEME":
                                ICategorySchemeObject tmpCategoryScheme = sdmxObjects.CategorySchemes.First(categoryScheme => categoryScheme.Id.Equals(currentId) && categoryScheme.AgencyId.Equals(currentAgency) && categoryScheme.Version.Equals(currentVersion));
                                newSdmxObjects.AddCategoryScheme(tmpCategoryScheme);
                                objectsSummary += string.Format(Resources.Messages.msg_category_scheme_imported, tmpCategoryScheme.Id, tmpCategoryScheme.AgencyId, tmpCategoryScheme.Version);
                                break;
                            case "DSD":
                                IDataStructureObject tmpDataStructure = sdmxObjects.DataStructures.First(dataStructure => dataStructure.Id.Equals(currentId) && dataStructure.AgencyId.Equals(currentAgency) && dataStructure.Version.Equals(currentVersion));
                                newSdmxObjects.AddDataStructure(tmpDataStructure);
                                objectsSummary += string.Format(Resources.Messages.msg_data_structure_imported, tmpDataStructure.Id, tmpDataStructure.AgencyId, tmpDataStructure.Version);
                                break;
                            case "AGENCY_SCHEME":
                                IAgencyScheme tmpAgencyScheme = sdmxObjects.AgenciesSchemes.First(agencyScheme => agencyScheme.Id.Equals(currentId) && agencyScheme.AgencyId.Equals(currentAgency) && agencyScheme.Version.Equals(currentVersion));
                                newSdmxObjects.AddAgencyScheme(tmpAgencyScheme);
                                objectsSummary += string.Format(Resources.Messages.msg_agency_scheme_imported, tmpAgencyScheme.Id, tmpAgencyScheme.AgencyId, tmpAgencyScheme.Version);
                                break;
                            case "DATA_PROVIDER_SCHEME":
                                IDataProviderScheme tmpDataProviderScheme = sdmxObjects.DataProviderSchemes.First(dataProviderScheme => dataProviderScheme.Id.Equals(currentId) && dataProviderScheme.AgencyId.Equals(currentAgency) && dataProviderScheme.Version.Equals(currentVersion));
                                newSdmxObjects.AddDataProviderScheme(tmpDataProviderScheme);
                                objectsSummary += string.Format(Resources.Messages.msg_data_provider_scheme_imported, tmpDataProviderScheme.Id, tmpDataProviderScheme.AgencyId, tmpDataProviderScheme.Version);
                                break;
                            case "DATA_CONSUMER_SCHEME":
                                IDataConsumerScheme tmpDataConsumerScheme = sdmxObjects.DataConsumerSchemes.First(dataConsumerScheme => dataConsumerScheme.Id.Equals(currentId) && dataConsumerScheme.AgencyId.Equals(currentAgency) && dataConsumerScheme.Version.Equals(currentVersion));
                                newSdmxObjects.AddDataConsumerScheme(tmpDataConsumerScheme);
                                objectsSummary += string.Format(Resources.Messages.msg_data_consumer_scheme_imported, tmpDataConsumerScheme.Id, tmpDataConsumerScheme.AgencyId, tmpDataConsumerScheme.Version);
                                break;
                            case "ORGANIZATION_UNIT_SCHEME":
                                IOrganisationUnitSchemeObject tmpOrganizationUnitScheme = sdmxObjects.OrganisationUnitSchemes.First(organizationUnitScheme => organizationUnitScheme.Id.Equals(currentId) && organizationUnitScheme.AgencyId.Equals(currentAgency) && organizationUnitScheme.Version.Equals(currentVersion));
                                newSdmxObjects.AddOrganisationUnitScheme(tmpOrganizationUnitScheme);
                                objectsSummary += string.Format(Resources.Messages.msg_organization_unit_scheme_imported, tmpOrganizationUnitScheme.Id, tmpOrganizationUnitScheme.AgencyId, tmpOrganizationUnitScheme.Version);
                                break;
                            case "STRUCTURE_SET":
                                IStructureSetObject tmpStructureSet = sdmxObjects.StructureSets.First(structureSet => structureSet.Id.Equals(currentId) && structureSet.AgencyId.Equals(currentAgency) && structureSet.Version.Equals(currentVersion));
                                newSdmxObjects.AddStructureSet(tmpStructureSet);
                                objectsSummary += string.Format(Resources.Messages.msg_structure_set_imported, tmpStructureSet.Id, tmpStructureSet.AgencyId, tmpStructureSet.Version);
                                break;
                            case "CONTENT_CONSTRAINT":
                                IContentConstraintObject tmpContentConstraint = sdmxObjects.ContentConstraintObjects.First(contentConstraint => contentConstraint.Id.Equals(currentId) && contentConstraint.AgencyId.Equals(currentAgency) && contentConstraint.Version.Equals(currentVersion));
                                newSdmxObjects.AddContentConstraintObject(tmpContentConstraint);
                                objectsSummary += string.Format(Resources.Messages.msg_content_constraint_imported, tmpContentConstraint.Id, tmpContentConstraint.AgencyId, tmpContentConstraint.Version);
                                break;
                            case "HIERARCHICAL_CODELIST":
                                IHierarchicalCodelistObject tmpHierarchicalCodelist = sdmxObjects.HierarchicalCodelists.First(hierarchicalCodelist => hierarchicalCodelist.Id.Equals(currentId) && hierarchicalCodelist.AgencyId.Equals(currentAgency) && hierarchicalCodelist.Version.Equals(currentVersion));
                                newSdmxObjects.AddHierarchicalCodelist(tmpHierarchicalCodelist);
                                objectsSummary += string.Format(Resources.Messages.msg_hierarchical_codelist_imported, tmpHierarchicalCodelist.Id, tmpHierarchicalCodelist.AgencyId, tmpHierarchicalCodelist.Version);
                                break;
                            case "CATEGORISATION":
                                ICategorisationObject tmpCategorisation = sdmxObjects.Categorisations.First(cat => cat.Id.Equals(currentId) && cat.AgencyId.Equals(currentAgency) && cat.Version.Equals(currentVersion));
                                newSdmxObjects.AddCategorisation(tmpCategorisation);
                                objectsSummary += string.Format(Resources.Messages.msg_categorisation_imported, tmpCategorisation.Id, tmpCategorisation.AgencyId, tmpCategorisation.Version);
                                break;
                        }
                        reportItems.Add(myCurrentItem);
                    }
                }
                Session[REPORT_ITEMS] = reportItems;

                // Carico l'SDMXObject in un XML Message da passare al WS
                //xDocMessage = utils.GetXmlMessage(newSdmxObjects);

                newSdmxObjects = PopolateAnnotationID(newSdmxObjects);

                //Richiamo il metodo SubmitStructure per l'inserimento nel DB
                try
                {
                    xRet = wsModel.SubmitStructure(newSdmxObjects);
                }
                catch (Exception ex)
                {
                    Utils.ShowDialog(ex.Message);
                    Utils.ForceBlackClosing();
                    return;
                }

                string CheckError = Utils.GetXMLResponseError(xRet);

                if (CheckError != String.Empty)
                {
                    Utils.ShowDialog(CheckError);
                    Utils.ForceBlackClosing();
                    return;
                }

                // lblInfo.Text = CreateArtefactImportedString(sdmxObjects);
                lblInfo.Text = objectsSummary;
                gridView.DataSource = null;
                gridView.DataBind();
            }
            else
            {
                Utils.ShowDialog( Resources.Messages.err_at_least_one_row );
                Utils.AppendScript("openPopUp('importedItemsGridDiv', 600);");
                return;
            }
            Utils.AppendScript("openPopUp('dialog-form', 600);");
            /*gridView.DataSource = myItems;
            gridView.DataBind();*/
        }
Example #13
0
        private XmlDocument WSSubmitStructure(XmlDocument xDom)
        {
            XmlDocument xDomOutput = new XmlDocument();

            try
            {
                WSUtils wsUtils = new WSUtils();

                WsConfigurationSettings wsSettings = wsUtils.GetSettings(WSConstants.wsOperation.SubmitStructure.ToString());

                string OutputFilePath = HttpContext.Current.Server.MapPath("OutputFiles" + "\\" + HttpContext.Current.Session.SessionID + ".xml");

                FlyCallWS.Streaming.CallWS objWS = new FlyCallWS.Streaming.CallWS(OutputFilePath, WSConstants.MaxOutputFileLength);

                xDomOutput.InnerXml = objWS.SendSOAPQuery(xDom, wsSettings);

                File.Delete(OutputFilePath);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return xDomOutput;
        }
        protected void btnUploadFile_Click(object sender, EventArgs e)
        {
            if (uploadedFiles.HasFile)
            {
                User currentUser = Session[SESSION_KEYS.USER_DATA] as User;

                try
                {
                    //ResetSdmxSession();
                    WSModel wsModel = new WSModel();
                    XmlDocument xDocStructure = new XmlDocument();
                    XmlDocument xDocMessage = new XmlDocument();
                    XmlDocument xRet;
                    WSUtils utils = new WSUtils();
                    ISdmxObjects sdmxObjects;

                    string FilePath = SaveFile();

                    // Carico il file in un XMLDOcument
                    xDocStructure.Load(FilePath);

                    // Carico l'XMLDocument in un SDMXObjects
                    sdmxObjects = utils.GetSdmxObjectsFromXML(xDocStructure);

                    List<ImportedItem> items = new List<ImportedItem>();
                    bool itemIsOk;
                    foreach (ICodelistObject tmpCodeList in sdmxObjects.Codelists)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetCodeList(new ArtefactIdentity(tmpCodeList.Id, tmpCodeList.AgencyId, tmpCodeList.Version), true, false);
                            if (checkedObject.Codelists.Count > 0)
                            {
                                ICodelistObject checkedCodelist = checkedObject.Codelists.First();
                                if (checkedCodelist.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }

                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpCodeList.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpCodeList), tmpCodeList.Id, tmpCodeList.AgencyId, tmpCodeList.Version, "CODELIST", itemIsOk));
                        }
                    }

                    foreach (IConceptSchemeObject tmpConceptScheme in sdmxObjects.ConceptSchemes)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetConceptScheme(new ArtefactIdentity(tmpConceptScheme.Id, tmpConceptScheme.AgencyId, tmpConceptScheme.Version), true, false);
                            if (checkedObject.ConceptSchemes.Count > 0)
                            {
                                IConceptSchemeObject checkedConcepScheme = checkedObject.ConceptSchemes.First();
                                if (checkedConcepScheme.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }

                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpConceptScheme.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpConceptScheme), tmpConceptScheme.Id, tmpConceptScheme.AgencyId, tmpConceptScheme.Version, "CONCEPT_SCHEME", itemIsOk));
                        }
                    }

                    foreach (ICategorySchemeObject tmpCategoryScheme in sdmxObjects.CategorySchemes)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetCategoryScheme(new ArtefactIdentity(tmpCategoryScheme.Id, tmpCategoryScheme.AgencyId, tmpCategoryScheme.Version), true, false);
                            if (checkedObject.CategorySchemes.Count > 0)
                            {
                                ICategorySchemeObject checkedCategoryScheme = checkedObject.CategorySchemes.First();
                                if (checkedCategoryScheme.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }

                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpCategoryScheme.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpCategoryScheme), tmpCategoryScheme.Id, tmpCategoryScheme.AgencyId, tmpCategoryScheme.Version, "CATEGORY_SCHEME", itemIsOk));
                        }
                    }

                    foreach (IDataStructureObject tmpDataStructure in sdmxObjects.DataStructures)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetDataStructure(new ArtefactIdentity(tmpDataStructure.Id, tmpDataStructure.AgencyId, tmpDataStructure.Version), true, false);
                            if (checkedObject.DataStructures.Count > 0)
                            {
                                IDataStructureObject checkedDataStructure = checkedObject.DataStructures.First();
                                if (checkedDataStructure.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }
                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpDataStructure.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpDataStructure), tmpDataStructure.Id, tmpDataStructure.AgencyId, tmpDataStructure.Version, "DSD", itemIsOk));
                        }
                    }

                    foreach (IAgencyScheme tmpAgencyScheme in sdmxObjects.AgenciesSchemes)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetAgencyScheme(new ArtefactIdentity(tmpAgencyScheme.Id, tmpAgencyScheme.AgencyId, tmpAgencyScheme.Version), true, false);
                            if (checkedObject.AgenciesSchemes.Count > 0)
                            {
                                IAgencyScheme checkedAgencyScheme = checkedObject.AgenciesSchemes.First();
                                if (checkedAgencyScheme.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }
                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpAgencyScheme.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpAgencyScheme), tmpAgencyScheme.Id, tmpAgencyScheme.AgencyId, tmpAgencyScheme.Version, "AGENCY_SCHEME", itemIsOk));
                        }
                    }

                    foreach (IDataProviderScheme tmpDataProviderScheme in sdmxObjects.DataProviderSchemes)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetDataProviderScheme(new ArtefactIdentity(tmpDataProviderScheme.Id, tmpDataProviderScheme.AgencyId, tmpDataProviderScheme.Version), true, false);
                            if (checkedObject.DataProviderSchemes.Count > 0)
                            {
                                IDataProviderScheme checkedDataProviderScheme = checkedObject.DataProviderSchemes.First();
                                if (checkedDataProviderScheme.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }
                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpDataProviderScheme.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpDataProviderScheme), tmpDataProviderScheme.Id, tmpDataProviderScheme.AgencyId, tmpDataProviderScheme.Version, "DATA_PROVIDER_SCHEME", itemIsOk));
                        }
                    }

                    foreach (IDataConsumerScheme tmpDataConsumerScheme in sdmxObjects.DataConsumerSchemes)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetDataConsumerScheme(new ArtefactIdentity(tmpDataConsumerScheme.Id, tmpDataConsumerScheme.AgencyId, tmpDataConsumerScheme.Version), true, false);
                            if (checkedObject.DataConsumerSchemes.Count > 0)
                            {
                                IDataConsumerScheme checkedDataConsumerScheme = checkedObject.DataConsumerSchemes.First();
                                if (checkedDataConsumerScheme.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }

                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpDataConsumerScheme.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpDataConsumerScheme), tmpDataConsumerScheme.Id, tmpDataConsumerScheme.AgencyId, tmpDataConsumerScheme.Version, "DATA_CONSUMER_SCHEME", itemIsOk));
                        }
                    }

                    foreach (IOrganisationUnitSchemeObject tmpOrganizationUnitScheme in sdmxObjects.OrganisationUnitSchemes)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetOrganisationUnitScheme(new ArtefactIdentity(tmpOrganizationUnitScheme.Id, tmpOrganizationUnitScheme.AgencyId, tmpOrganizationUnitScheme.Version), true, false);
                            if (checkedObject.OrganisationUnitSchemes.Count > 0)
                            {
                                IOrganisationUnitSchemeObject checkedOrganisationUnitScheme = checkedObject.OrganisationUnitSchemes.First();
                                if (checkedOrganisationUnitScheme.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }

                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpOrganizationUnitScheme.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpOrganizationUnitScheme), tmpOrganizationUnitScheme.Id, tmpOrganizationUnitScheme.AgencyId, tmpOrganizationUnitScheme.Version, "ORGANIZATION_UNIT_SCHEME", itemIsOk));
                        }
                    }

                    foreach (IContentConstraintObject tmpContentConstraint in sdmxObjects.ContentConstraintObjects)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetContentConstraint(new ArtefactIdentity(tmpContentConstraint.Id, tmpContentConstraint.AgencyId, tmpContentConstraint.Version), true, false);
                            if (checkedObject.ContentConstraintObjects.Count > 0)
                            {
                                IContentConstraintObject checkedContentConstraint = checkedObject.ContentConstraintObjects.First();
                                if (checkedContentConstraint.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }
                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpContentConstraint.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpContentConstraint), tmpContentConstraint.Id, tmpContentConstraint.AgencyId, tmpContentConstraint.Version, "CONTENT_CONSTRAINT", itemIsOk));
                        }
                    }

                    foreach (IStructureSetObject tmpStructureSet in sdmxObjects.StructureSets)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetStructureSet(new ArtefactIdentity(tmpStructureSet.Id, tmpStructureSet.AgencyId, tmpStructureSet.Version), true, false);
                            if (checkedObject.StructureSets.Count > 0)
                            {
                                IStructureSetObject checkedStructureSet = checkedObject.StructureSets.First();
                                if (checkedStructureSet.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }
                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpStructureSet.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpStructureSet), tmpStructureSet.Id, tmpStructureSet.AgencyId, tmpStructureSet.Version, "STRUCTURE_SET", itemIsOk));
                        }
                    }

                    foreach (IHierarchicalCodelistObject tmpHierarchicalCodelist in sdmxObjects.HierarchicalCodelists)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetHcl(new ArtefactIdentity(tmpHierarchicalCodelist.Id, tmpHierarchicalCodelist.AgencyId, tmpHierarchicalCodelist.Version), true, false);
                            if (checkedObject.HierarchicalCodelists.Count > 0)
                            {
                                IHierarchicalCodelistObject checkedHierarchicalCodelist = checkedObject.HierarchicalCodelists.First();
                                if (checkedHierarchicalCodelist.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }
                        var foundAgency = (from agency in currentUser.agencies
                                          where agency.id.Equals( tmpHierarchicalCodelist.AgencyId.ToString() )
                                          select agency).ToList<UserAgency>();

                        if ( foundAgency.Count > 0 )
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpHierarchicalCodelist), tmpHierarchicalCodelist.Id, tmpHierarchicalCodelist.AgencyId, tmpHierarchicalCodelist.Version, "HIERARCHICAL_CODELIST", itemIsOk));
                        }
                    }

                    foreach (ICategorisationObject tmpCatObj in sdmxObjects.Categorisations)
                    {
                        itemIsOk = true;
                        try
                        {
                            ISdmxObjects checkedObject = wsModel.GetCategorisation(new ArtefactIdentity(tmpCatObj.Id, tmpCatObj.AgencyId, tmpCatObj.Version), true, false);
                            if (checkedObject.Categorisations.Count > 0)
                            {
                                ICategorisationObject checkedCategorisation = checkedObject.Categorisations.First();
                                if (checkedCategorisation.IsFinal.IsTrue)
                                {
                                    itemIsOk = false;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            itemIsOk = true;
                        }
                        var foundAgency = (from agency in currentUser.agencies
                                           where agency.id.Equals(tmpCatObj.AgencyId.ToString())
                                           select agency).ToList<UserAgency>();

                        if (foundAgency.Count > 0)
                        {
                            items.Add(new ImportedItem(localizedUtils.GetNameableName(tmpCatObj), tmpCatObj.Id, tmpCatObj.AgencyId, tmpCatObj.Version, "CATEGORISATION", itemIsOk));
                        }
                    }
                    Session[IMPORTED_ITEMS_STRING] = items;
                    Session[IMPORTED_SDMX_OBJECT] = sdmxObjects;
                    gridView.DataSource = items;
                    gridView.DataBind();
                    if ( items.Count != 0 )
                    {
                        btnConfirmImport.Visible = true;
                        lblNoItemsAllowed.Visible = false;
                    }
                    else
                    {
                        Utils.AppendScript( "$('#chbSelectAll').hide();" );
                        lblSelectAll.Visible = false;
                        lblNoItemsAllowed.Visible = true;
                        btnConfirmImport.Visible = false;
                    }

                    Utils.AppendScript("openPopUp('importedItemsGridDiv', 600);");
                }
                catch (Exception ex)
                {
                    string msg;
                    if (ex.InnerException != null)
                        msg = ex.InnerException.Message;
                    else
                        msg = ex.Message;

                    Utils.ShowDialog(msg);
                }
            }
            else
            {
                Utils.ShowDialog( Resources.Messages.err_no_file_uploaded );
            }
        }
Example #15
0
            public virtual string GetValues(string location, string variable, string startDate, string endDate, String authToken)
            {
                TimeSeriesResponseType aSite = GetValuesObject(location, variable, startDate, endDate, null);

                return(WSUtils.ConvertToXml(aSite, typeof(TimeSeriesResponseType)));
            }
 public AmerifluxService()
 {
     utils = new WSUtils();
     GetSites(true, true, true);
 }
Example #17
0
        public XmlDocument SubmitStructure(ISdmxObjects sdmxObjects)
        {
            WSUtils wsUtils = new WSUtils();

            return WSSubmitStructure(wsUtils.GetXmlMessage(sdmxObjects));
        }
        protected void btnDelete_Click(object sender, EventArgs e)
        {
            /*
             * 1. Faccio il retrieve dell'artefact da eliminare
             * 2. Ottengo un SDMXObjects
             * 3. Trasformo l'SDMXObjects in un oggetto xml
             * 4. Carico il template
             * 5. Cerco il tag "structures" nell'sdmxobjects che contiene l'artefatto da eliminare
             * 6. Inserisco il contenuto dello structure nel template
             * 7. Richiamo il metodo submitstructure per effettuare l'eliminazione
             * 8. Controllo il successo dell'eliminazione e rifaccio il DataBind()
             */

            WSModel wsModel = new WSModel();
            WSUtils wsUtils = new WSUtils();
            ISdmxObjects sdmxObjects;
            XmlDocument xDocStructure;
            XmlDocument xDocTemplate;
            XmlDocument xDocResponse;

            try
            {
                //sdmxObjects = wsModel.GetCodeList(new ArtefactIdentity(ucID, ucAgency, ucVersion), true);

                sdmxObjects = GetSdmxObjects();

                xDocStructure = wsUtils.GetXMLDocFromSdmxObjects(sdmxObjects, StructureOutputFormatEnumType.SdmxV21StructureDocument);

                //Carico il template
                xDocTemplate = new XmlDocument();
                xDocTemplate.Load(Server.MapPath(@".\SdmxQueryTemplate\SubmitStructureDelete.xml"));

                // Il nodo root "Structure" del template
                XmlNode xTempStructNode = xDocTemplate.SelectSingleNode("//*[local-name()='Structures']");

                // Aggiungo al template lo structure da eliminare
                xTempStructNode.InnerXml = xDocStructure.SelectSingleNode("//*[local-name()='Structures']").InnerXml;

                // Richiamo il SubmitStructure per effettuare la Delete
                xDocResponse = wsModel.SubmitStructure(xDocTemplate);

                string CheckError = Utils.GetXMLResponseError(xDocResponse);

                if (CheckError != String.Empty)
                {
                    //Utils.ShowDialog(CheckError);
                    Utils.ShowDialog( Resources.Messages.err_artefact_is_a_reference );
                    Utils.ForceBlackClosing();
                    return;
                }

                //Utils.ExecuteScript(Parent.Page, "location.reload();");
                Utils.ReloadPage();
               //ScriptManager.RegisterStartupScript(this, typeof(Page), UniqueID, "closePopup();", true);
            }
            catch (Exception ex)
            {
                Utils.AppendScript("closePopup();");
                Utils.ShowDialog("An error occurred: " + ex.Message);
            }
        }
        public XmlDocument SubmitStructure(ISdmxObjects sdmxObjects)
        {
            WSUtils wsUtils = new WSUtils();

            if (FinalArtefactExists(sdmxObjects))
                return CreateXMLError("The artefact exists and is final!");

            return WSSubmitStructure(wsUtils.GetXmlMessage(sdmxObjects));
        }