Example #1
0
        public static string CreateConvertedMetadata(long datasetId, TransmissionType type)
        {
            XmlDocument              newXml;
            DatasetManager           datasetManager = new DatasetManager();
            MetadataStructureManager metadataMetadataStructureManager = new MetadataStructureManager();

            try
            {
                DatasetVersion    datasetVersion    = datasetManager.GetDatasetLatestVersion(datasetId);
                MetadataStructure metadataStructure = metadataMetadataStructureManager.Repo.Get(datasetVersion.Dataset.MetadataStructure.Id);
                XmlDatasetHelper  xmlDatasetHelper  = new XmlDatasetHelper();

                int    versionNr   = datasetManager.GetDatasetVersionNr(datasetVersion);
                string mappingName = metadataStructure.Name;

                string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName);
                //if mapping file not exist
                if (string.IsNullOrEmpty(mappingFileName))
                {
                    return("");
                }
                string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName);

                XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
                xmlMapperManager.Load(pathMappingFile, "exporttest");

                newXml = xmlMapperManager.Export(datasetVersion.Metadata, datasetVersion.Id, mappingName, true);

                string title = datasetVersion.Title;

                // store in content descriptor
                string filename = "metadata";
                if (String.IsNullOrEmpty(mappingName) || mappingName.ToLower() == "generic")
                {
                    storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, filename, ".xml");
                }
                else
                {
                    filename = "metadata_" + mappingName;
                    storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, filename,
                                                              ".xml");
                }

                return(OutputDatasetManager.GetDynamicDatasetStorePath(datasetId, versionNr, filename, ".xml"));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                datasetManager.Dispose();
                metadataMetadataStructureManager.Dispose();
            }
        }
Example #2
0
        public static XmlDocument GetConvertedMetadata(long datasetId, TransmissionType type, string mappingName, bool storing = true)
        {
            using (DatasetManager datasetManager = new DatasetManager())
            {
                XmlDocument newXml;

                try
                {
                    DatasetVersion   datasetVersion   = datasetManager.GetDatasetLatestVersion(datasetId);
                    XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();

                    string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName);
                    // no mapping files with mappingName exist
                    if (string.IsNullOrEmpty(mappingFileName))
                    {
                        return(null);
                    }

                    string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName);

                    XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
                    xmlMapperManager.Load(pathMappingFile, "exporttest");

                    newXml = xmlMapperManager.Export(datasetVersion.Metadata, datasetVersion.Id, mappingName, true);

                    string title = datasetVersion.Title;

                    // store in content descriptor
                    if (storing)
                    {
                        if (String.IsNullOrEmpty(mappingName) || mappingName.ToLower() == "generic")
                        {
                            storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "metadata", ".xml");
                        }
                        else
                        {
                            storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "metadata_" + mappingName, ".xml");
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw ex;
                }

                return(newXml);
            }
        }
Example #3
0
        public static string IsValideAgainstSchema(long datasetId, TransmissionType type, string mappingName)
        {
            DatasetManager datasetManager = new DatasetManager();

            try
            {
                XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();

                DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);

                string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName);
                // if mapping file not exists
                if (string.IsNullOrEmpty(mappingFileName))
                {
                    return("");
                }
                string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName);

                XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
                xmlMapperManager.Load(pathMappingFile, "exporttest");

                XmlDocument tmp = GetConvertedMetadata(datasetId, type, mappingName, false);

                string path = Path.Combine(AppConfiguration.DataPath, "Temp", "System", "convertedMetadata.xml");

                if (FileHelper.FileExist(path))
                {
                    FileHelper.Delete(path);
                }

                FileHelper.CreateDicrectoriesIfNotExist(Path.GetDirectoryName(path));

                tmp.Save(path);
                XmlDocument metadataForImport = new XmlDocument();
                metadataForImport.Load(path);

                return(xmlMapperManager.Validate(metadataForImport));
            }
            catch (Exception ex)
            {
                return(ex.Message);
            }
            finally
            {
                datasetManager.Dispose();
            }
        }
Example #4
0
        public async Task <HttpResponseMessage> Put(int id)
        {
            var    request = Request.CreateResponse();
            User   user    = null;
            string error   = "";

            DatasetManager          datasetManager          = new DatasetManager();
            UserManager             userManager             = new UserManager();
            EntityPermissionManager entityPermissionManager = new EntityPermissionManager();

            try
            {
                #region security

                string token = this.Request.Headers.Authorization?.Parameter;

                if (String.IsNullOrEmpty(token))
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "Bearer token not exist."));
                }

                user = userManager.Users.Where(u => u.Token.Equals(token)).FirstOrDefault();

                if (user == null)
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Token is not valid."));
                }

                //check permissions

                //entity permissions
                if (id > 0)
                {
                    Dataset d = datasetManager.GetDataset(id);
                    if (d == null)
                    {
                        return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "the dataset with the id (" + id + ") does not exist."));
                    }

                    if (!entityPermissionManager.HasEffectiveRight(user.Name, typeof(Dataset), id, RightType.Write))
                    {
                        return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "The token is not authorized to write into the dataset."));
                    }
                }

                #endregion security

                #region check incomming metadata

                Stream requestStream = await this.Request.Content.ReadAsStreamAsync();

                string contentType = this.Request.Content.Headers.ContentType.MediaType;

                if (string.IsNullOrEmpty(contentType) || (!contentType.Equals("application/xml") && !contentType.Equals("text/plain")))
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "The transmitted file is not a xml document."));
                }

                if (requestStream == null)
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "Metadata xml was not received."));
                }

                #endregion check incomming metadata

                #region incomming values check

                // check incomming values

                if (id == 0)
                {
                    error += "dataset id should be greater then 0.";
                }
                ////if (data.UpdateMethod == null) error += "update method is not set";
                ////if (data.Count == 0) error += "count should be greater then 0. ";
                //if (data.Columns == null) error += "cloumns should not be null. ";
                //if (data.Data == null) error += "data is empty. ";
                //if (data.PrimaryKeys == null || data.PrimaryKeys.Count() == 0) error += "the UpdateMethod update has been selected but there are no primary keys available. ";

                if (!string.IsNullOrEmpty(error))
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, error));
                }

                #endregion incomming values check

                Dataset dataset = datasetManager.GetDataset(id);
                if (dataset == null)
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "Dataset not exist."));
                }

                #region convert metadata

                XmlDocument metadataForImport = new XmlDocument();
                metadataForImport.Load(requestStream);

                // metadataStructure ID
                var metadataStructureId   = dataset.MetadataStructure.Id;
                var metadataStructrueName = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId).Name;

                // loadMapping file
                var path_mappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), XmlMetadataImportHelper.GetMappingFileName(metadataStructureId, TransmissionType.mappingFileImport, metadataStructrueName));

                // XML mapper + mapping file
                var xmlMapperManager = new XmlMapperManager(TransactionDirection.ExternToIntern);
                xmlMapperManager.Load(path_mappingFile, "IDIV");

                // generate intern metadata without internal attributes
                var metadataResult = xmlMapperManager.Generate(metadataForImport, 1, true);

                // generate intern template metadata xml with needed attribtes
                var xmlMetadatWriter = new XmlMetadataWriter(BExIS.Xml.Helpers.XmlNodeMode.xPath);
                var metadataXml      = xmlMetadatWriter.CreateMetadataXml(metadataStructureId,
                                                                          XmlUtility.ToXDocument(metadataResult));

                var metadataXmlTemplate = XmlMetadataWriter.ToXmlDocument(metadataXml);

                // set attributes FROM metadataXmlTemplate TO metadataResult
                var completeMetadata = XmlMetadataImportHelper.FillInXmlValues(metadataResult,
                                                                               metadataXmlTemplate);

                #endregion convert metadata

                if (completeMetadata != null)
                {
                    string title = "";
                    if (datasetManager.IsDatasetCheckedOutFor(id, user.Name) || datasetManager.CheckOutDataset(id, user.Name))
                    {
                        DatasetVersion workingCopy = datasetManager.GetDatasetWorkingCopy(id);
                        workingCopy.Metadata    = completeMetadata;
                        workingCopy.Title       = xmlDatasetHelper.GetInformation(id, completeMetadata, NameAttributeValues.title);
                        workingCopy.Description = xmlDatasetHelper.GetInformation(id, completeMetadata, NameAttributeValues.description);

                        //check if modul exist
                        int v = 1;
                        if (workingCopy.Dataset.Versions != null && workingCopy.Dataset.Versions.Count > 1)
                        {
                            v = workingCopy.Dataset.Versions.Count();
                        }

                        //set status
                        if (workingCopy.StateInfo == null)
                        {
                            workingCopy.StateInfo = new Vaiona.Entities.Common.EntityStateInfo();
                        }
                        workingCopy.StateInfo.State = DatasetStateInfo.NotValid.ToString();

                        title = workingCopy.Title;
                        if (string.IsNullOrEmpty(title))
                        {
                            title = "No Title available.";
                        }

                        datasetManager.EditDatasetVersion(workingCopy, null, null, null);
                        datasetManager.CheckInDataset(id, "via api.", user.Name, ViewCreationBehavior.None);
                    }

                    // ToDo add Index update to this api
                    //if (this.IsAccessible("DDM", "SearchIndex", "ReIndexSingle"))
                    //{
                    //    var x = this.Run("DDM", "SearchIndex", "ReIndexSingle", new RouteValueDictionary() { { "id", datasetId } });
                    //}

                    LoggerFactory.LogData(id.ToString(), typeof(Dataset).Name, Vaiona.Entities.Logging.CrudState.Created);

                    var es = new EmailService();
                    es.Send(MessageHelper.GetUpdateDatasetHeader(id),
                            MessageHelper.GetUpdateDatasetMessage(id, title, user.DisplayName),
                            ConfigurationManager.AppSettings["SystemEmail"]
                            );
                }

                return(Request.CreateErrorResponse(HttpStatusCode.OK, "Metadata successfully updated "));
            }
            catch (Exception ex)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
            }
            finally
            {
                datasetManager.Dispose();
                entityPermissionManager.Dispose();
                userManager.Dispose();
                request.Dispose();
            }
        }