Ejemplo n.º 1
0
        public Guid NewVersioningGroup(Models.RegisterItem registerItem)
        {
            Models.Version versjoneringsGruppe = new Models.Version();
            versjoneringsGruppe.systemId           = Guid.NewGuid();
            versjoneringsGruppe.currentVersion     = registerItem.systemId;
            versjoneringsGruppe.containedItemClass = registerItem.register.containedItemClass;
            versjoneringsGruppe.lastVersionNumber  = registerItem.versionNumber;

            _dbContext.Entry(versjoneringsGruppe).State = EntityState.Modified;
            _dbContext.Versions.Add(versjoneringsGruppe);
            _dbContext.SaveChanges();
            return(versjoneringsGruppe.systemId);
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> PutTestRegister(int id, TestRegister testRegister)
        {
            if (id != testRegister.TestRegisterId)
            {
                return(BadRequest());
            }

            _context.Entry(testRegister).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TestRegisterExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public ActionResult DeleteConfirmed(string registername, string itemname, string itemowner, string parentregister)
        {
            var queryResults = from o in _db.CodelistValues
                               where o.seoname == itemname && o.register.seoname == registername && o.register.parentRegister.seoname == parentregister
                               select o.systemId;

            Guid systId = queryResults.FirstOrDefault();

            CodelistValue codelistValue = _db.CodelistValues.Find(systId);
            string        parent        = null;

            if (codelistValue.register.parentRegisterId != null)
            {
                parent = codelistValue.register.parentRegister.path;
            }

            _registerItemService.RemoveBroaderAndNarrower(codelistValue);
            codelistValue.broaderItemId = null;
            codelistValue.narrowerItems.Clear();


            _db.Entry(codelistValue).State = EntityState.Modified;
            _db.SaveChanges();

            _db.RegisterItems.Remove(codelistValue);
            _db.SaveChanges();
            if (parent != null)
            {
                return(Redirect("/" + parent));
            }
            return(Redirect("/register/" + registername));
        }
Ejemplo n.º 4
0
        private void UpdateCurrentVersion(Document originalDocument)
        {
            var newCurrentVersion = _versioningService.GetLatestSupersededVersion(originalDocument.versioningId);

            if (newCurrentVersion == null)
            {
                newCurrentVersion = _versioningService.SetLatestDocumentWithStatusIdDraftAsCurrent(originalDocument.versioningId);
                if (newCurrentVersion == null)
                {
                    newCurrentVersion = _versioningService.SetLatestDocumentWithStatusIdSubmittedAsCurrent(originalDocument.versioningId);
                    if (newCurrentVersion == null)
                    {
                        newCurrentVersion = _versioningService.SetLatestDocumentWithStatusIdRetiredAsCurrent(originalDocument.versioningId);
                    }
                }
            }
            else
            {
                newCurrentVersion.statusId       = "Valid";
                newCurrentVersion.modified       = DateTime.Now;
                newCurrentVersion.dateSuperseded = null;
            }
            _versioningService.UpdateCurrentVersionOfVersionGroup(newCurrentVersion.versioningId, newCurrentVersion.systemId);

            _dbContext.Entry(originalDocument.versioning).State = EntityState.Modified;
            _dbContext.SaveChanges();
        }
Ejemplo n.º 5
0
 public void Update(T entity)
 {
     if (!DataSet.Local.Contains(entity))
     {
         DataSet.Attach(entity);
         _dbContext.Entry(entity).State = EntityState.Modified;
     }
     _dbContext.SaveChanges();
 }
        /// <summary>
        /// If you delete or change status on current version, it needs to be replaced by another version
        /// </summary>
        /// <param name="document"></param>
        private void GetNewCurrentVersion(Document document)
        {
            var versionsOfDocument = _registerItemService.GetAllVersionsOfItembyVersioningId(document.versioning.systemId);

            foreach (var item in versionsOfDocument.Where(d => d.statusId == "Superseded").OrderByDescending(d => d.dateAccepted))
            {
                document.versioning.currentVersion = item.systemId;
                item.statusId       = "Valid";
                item.modified       = DateTime.Now;
                item.dateSuperseded = null;
                break;
            }
            if (document.versioning.currentVersion == document.systemId)
            {
                Document nyGjeldendeVersjon = (Document)versionsOfDocument.Where(o => o.statusId == "Draft").Where(o => o.systemId != document.systemId).OrderBy(d => d.dateSubmitted).FirstOrDefault();
                if (nyGjeldendeVersjon != null)
                {
                    document.versioning.currentVersion = nyGjeldendeVersjon.systemId;
                }
                else
                {
                    nyGjeldendeVersjon = (Document)versionsOfDocument.Where(o => o.statusId == "Submitted").Where(o => o.systemId != document.systemId).OrderBy(d => d.dateSubmitted).FirstOrDefault();
                    if (nyGjeldendeVersjon != null)
                    {
                        document.versioning.currentVersion = nyGjeldendeVersjon.systemId;
                    }
                    else
                    {
                        nyGjeldendeVersjon = (Document)versionsOfDocument.Where(o => o.statusId == "Retired").Where(o => o.systemId != document.systemId).OrderByDescending(d => d.DateRetired).FirstOrDefault();
                        if (nyGjeldendeVersjon != null)
                        {
                            document.versioning.currentVersion = nyGjeldendeVersjon.systemId;
                        }
                        else
                        {
                            nyGjeldendeVersjon = (Document)versionsOfDocument.FirstOrDefault();
                        }
                    }
                }
            }
            db.Entry(document.versioning).State = EntityState.Modified;
            db.SaveChanges();
        }
        //[Route("navnerom/{parentRegister}/{registerowner}/{registername}/{itemowner}/{itemname}/rediger")]
        //[Route("navnerom/{registername}/{itemowner}/{itemname}/rediger")]
        public ActionResult Edit(NameSpace nameSpace, string registerId, string systemId)
        {
            NameSpace originalNameSpace = GetRegisterItem(systemId);

            Models.Register register = GetRegister(registerId);
            ValidationName(nameSpace, register);

            if (ModelState.IsValid)
            {
                if (nameSpace.name != null)
                {
                    originalNameSpace.name = nameSpace.name;
                }
                originalNameSpace.seoname = Helpers.RegisterUrls.MakeSeoFriendlyString(originalNameSpace.name);
                if (nameSpace.description != null)
                {
                    originalNameSpace.description = nameSpace.description;
                }
                if (nameSpace.submitterId != null)
                {
                    originalNameSpace.submitterId = nameSpace.submitterId;
                }
                if (nameSpace.statusId != null)
                {
                    originalNameSpace.statusId = nameSpace.statusId;
                }
                if (nameSpace.serviceUrl != null)
                {
                    originalNameSpace.serviceUrl = nameSpace.serviceUrl;
                }

                if (nameSpace.statusId != null)
                {
                    if (nameSpace.statusId == "Valid" && originalNameSpace.statusId != "Valid")
                    {
                        originalNameSpace.dateAccepted = DateTime.Now;
                    }
                    if (originalNameSpace.statusId == "Valid" && nameSpace.statusId != "Valid")
                    {
                        originalNameSpace.dateAccepted = null;
                    }
                    originalNameSpace.statusId = nameSpace.statusId;
                }

                originalNameSpace.modified         = DateTime.Now;
                _db.Entry(originalNameSpace).State = EntityState.Modified;
                _translationService.UpdateTranslations(nameSpace, originalNameSpace);
                _db.SaveChanges();

                Viewbags(originalNameSpace);
                return(Redirect(originalNameSpace.GetObjectUrl()));
            }
            Viewbags(originalNameSpace);
            return(View(originalNameSpace));
        }
        //[Route("ny")]
        public ActionResult Create(Models.Register register)
        {
            if (IsAdmin())
            {
                if (_registerService.RegisterNameIsValid(register))
                {
                    ModelState.AddModelError("ErrorMessage", Registers.ErrorMessageValidationName);
                }

                if (ModelState.IsValid)
                {
                    register.systemId = Guid.NewGuid();
                    if (register.name == null)
                    {
                        register.name = "ikke angitt";
                    }
                    register.systemId           = Guid.NewGuid();
                    register.modified           = DateTime.Now;
                    register.dateSubmitted      = DateTime.Now;
                    register.statusId           = "Submitted";
                    register.seoname            = RegisterUrls.MakeSeoFriendlyString(register.name);
                    register.containedItemClass = register.containedItemClass;

                    _db.Registers.Add(register);
                    _db.SaveChanges();

                    Organization submitterOrganisasjon = _registerService.GetOrganizationByUserName();
                    register.ownerId   = submitterOrganisasjon.systemId;
                    register.managerId = submitterOrganisasjon.systemId;

                    _db.Entry(register).State = EntityState.Modified;
                    _db.SaveChanges();
                    return(Redirect("/"));
                }
                ViewBag.containedItemClass = new SelectList(_db.ContainedItemClass.OrderBy(s => s.description), "value", "description", string.Empty);
                return(View());
            }
            return(HttpNotFound());
        }
Ejemplo n.º 9
0
        public CoverageDataset NewCoverage(Dataset dataset)
        {
            CoverageDataset coverage = new CoverageDataset();

            coverage.CoverageId           = Guid.NewGuid();
            coverage.CoverageDOKStatusId  = "Accepted";
            coverage.ConfirmedDok         = true;
            coverage.DatasetId            = dataset.systemId;
            dataset.dokStatusDateAccepted = DateTime.Now;
            coverage.MunicipalityId       = dataset.datasetownerId;
            coverage.Note     = dataset.Notes;
            coverage.Coverage = null;

            _context.Entry(coverage).State = EntityState.Modified;
            _context.CoverageDatasets.Add(coverage);
            return(coverage);
        }
        public IHttpActionResult PutServiceAlert(string id, AlertUpdate alert)
        {
            var originalAlert = _dbContext.Alerts.Where(a => a.systemId.ToString() == id).FirstOrDefault();

            if (originalAlert == null)
            {
                return(NotFound());
            }

            originalAlert.Summary      = alert.Summary;
            originalAlert.DateResolved = alert.DateResolved;

            originalAlert.register.modified       = System.DateTime.Now;
            _dbContext.Entry(originalAlert).State = EntityState.Modified;
            _dbContext.SaveChanges();

            return(StatusCode(HttpStatusCode.NoContent));
        }
Ejemplo n.º 11
0
        public Dataset UpdateDatasetWithMetadata(Dataset dataset, string uuid, bool dontUpdateDescription)
        {
            Dataset metadata = FetchDatasetFromKartkatalogen(uuid);

            if (metadata != null)
            {
                dataset.Uuid                    = uuid;
                dataset.name                    = metadata.name;
                dataset.seoname                 = RegisterUrls.MakeSeoFriendlyString(dataset.name);
                dataset.description             = metadata.description;
                dataset.MetadataUrl             = WebConfigurationManager.AppSettings["KartkatalogenUrl"] + "metadata/uuid/" + uuid;
                dataset.PresentationRulesUrl    = metadata.PresentationRulesUrl;
                dataset.ProductSheetUrl         = metadata.ProductSheetUrl;
                dataset.ProductSpecificationUrl = metadata.ProductSpecificationUrl;
                dataset.datasetthumbnail        = metadata.datasetthumbnail;

                dataset.datasetownerId = metadata.datasetownerId;
                dataset.ThemeGroupId   = metadata.ThemeGroupId;
                dataset.UuidService    = metadata.UuidService;
                dataset.WmsUrl         = metadata.WmsUrl;
                dataset.SpecificUsage  = metadata.SpecificUsage;

                dataset.restricted = metadata.restricted;

                dataset.DistributionUrl  = metadata.DistributionUrl;
                dataset.DistributionArea = metadata.DistributionArea;

                if (metadata.DistributionFormat != null)
                {
                    dataset.DistributionFormat = metadata.DistributionFormat;
                }

                dataset.Translations.Where(t => t.RegisterItemId != Guid.Empty).ToList().ForEach(x => _dbContext.Entry(x).State = EntityState.Deleted);
                dataset.Translations = metadata.Translations;
            }

            return(dataset);
        }
Ejemplo n.º 12
0
        //[Route("epsg/{parentRegister}/{registerowner}/{registername}/{itemowner}/{epsgname}/rediger")]
        //[Route("epsg/{registername}/{organization}/{epsgname}/rediger")]
        //public ActionResult Edit(EPSG ePSG, string name, string id)
        public ActionResult Edit(EPSG ePSG, string epsgname, string parentRegister, string registername)
        {
            var queryResultsOrganisasjon = from o in db.EPSGs
                                           where o.seoname == epsgname &&
                                           o.register.seoname == registername &&
                                           o.register.parentRegister.seoname == parentRegister
                                           select o.systemId;

            Guid systId = queryResultsOrganisasjon.FirstOrDefault();
            EPSG epsg   = db.EPSGs.Find(systId);

            var queryResultsRegister = from o in db.Registers
                                       where o.seoname == registername && o.parentRegister.seoname == parentRegister
                                       select o.systemId;

            Guid regId = queryResultsRegister.FirstOrDefault();

            Models.Register register = db.Registers.Find(regId);

            ValidationName(ePSG, register);

            if (ModelState.IsValid)
            {
                EPSG originalEPSG = db.EPSGs.Find(systId);

                if (ePSG.name != null)
                {
                    originalEPSG.name = ePSG.name;
                }
                originalEPSG.seoname = Helpers.RegisterUrls.MakeSeoFriendlyString(originalEPSG.name);
                if (ePSG.description != null)
                {
                    originalEPSG.description = ePSG.description;
                }
                if (ePSG.submitterId != null)
                {
                    originalEPSG.submitterId = ePSG.submitterId;
                }
                if (ePSG.statusId != null)
                {
                    originalEPSG.statusId = ePSG.statusId;
                }
                if (ePSG.epsgcode != null)
                {
                    originalEPSG.epsgcode = ePSG.epsgcode;
                }
                if (ePSG.verticalReferenceSystem != null)
                {
                    originalEPSG.verticalReferenceSystem = ePSG.verticalReferenceSystem;
                }
                if (ePSG.horizontalReferenceSystem != null)
                {
                    originalEPSG.horizontalReferenceSystem = ePSG.horizontalReferenceSystem;
                }
                if (ePSG.dimensionId != null)
                {
                    originalEPSG.dimensionId = ePSG.dimensionId;
                }
                if (ePSG.sosiReferencesystem != null)
                {
                    originalEPSG.sosiReferencesystem = ePSG.sosiReferencesystem;
                }
                if (ePSG.externalReference != null)
                {
                    originalEPSG.externalReference = ePSG.externalReference;
                }
                if (ePSG.inspireRequirementId != null)
                {
                    originalEPSG.inspireRequirementId = ePSG.inspireRequirementId;
                }
                if (ePSG.inspireRequirementDescription != null)
                {
                    originalEPSG.inspireRequirementDescription = ePSG.inspireRequirementDescription;
                }
                if (ePSG.nationalRequirementId != null)
                {
                    originalEPSG.nationalRequirementId = ePSG.nationalRequirementId;
                }
                if (ePSG.nationalRequirementDescription != null)
                {
                    originalEPSG.nationalRequirementDescription = ePSG.nationalRequirementDescription;
                }
                if (ePSG.nationalSeasRequirementId != null)
                {
                    originalEPSG.nationalSeasRequirementId = ePSG.nationalSeasRequirementId;
                }
                if (ePSG.nationalSeasRequirementDescription != null)
                {
                    originalEPSG.nationalSeasRequirementDescription = ePSG.nationalSeasRequirementDescription;
                }
                if (ePSG.statusId != null)
                {
                    if (ePSG.statusId == "Valid" && originalEPSG.statusId != "Valid")
                    {
                        originalEPSG.dateAccepted = DateTime.Now;
                    }
                    if (originalEPSG.statusId == "Valid" && ePSG.statusId != "Valid")
                    {
                        originalEPSG.dateAccepted = null;
                    }
                    originalEPSG.statusId = ePSG.statusId;
                }
                _translationService.UpdateTranslations(ePSG, originalEPSG);
                originalEPSG.modified        = DateTime.Now;
                db.Entry(originalEPSG).State = EntityState.Modified;
                db.SaveChanges();

                Viewbags(ePSG);
                if (!String.IsNullOrWhiteSpace(parentRegister))
                {
                    return(Redirect("/subregister/" + originalEPSG.register.parentRegister.seoname + "/" + originalEPSG.register.parentRegister.owner.seoname + "/" + registername + "/" + "/" + originalEPSG.submitter.seoname + "/" + originalEPSG.seoname));
                }
                else
                {
                    return(Redirect("/register/" + registername + "/" + originalEPSG.submitter.seoname + "/" + originalEPSG.seoname));
                }
            }
            Viewbags(ePSG);
            return(View(epsg));
        }
Ejemplo n.º 13
0
        public InspireDataset UpdateInspireDataset(InspireDatasetViewModel viewModel)
        {
            var inspireDataset = GetInspireDatasetBySystemId(viewModel.SystemId);

            inspireDataset.Name          = viewModel.Name;
            inspireDataset.Seoname       = RegisterUrls.MakeSeoFriendlyString(inspireDataset.Name);
            inspireDataset.Description   = viewModel.Description;
            inspireDataset.SubmitterId   = viewModel.SubmitterId;
            inspireDataset.OwnerId       = viewModel.OwnerId;
            inspireDataset.Modified      = DateTime.Now;
            inspireDataset.DateSubmitted = DateTime.Now;
            inspireDataset.RegisterId    = viewModel.RegisterId;

            inspireDataset.Uuid                    = viewModel.Uuid;
            inspireDataset.Notes                   = viewModel.Notes;
            inspireDataset.SpecificUsage           = viewModel.SpecificUsage;
            inspireDataset.ProductSheetUrl         = viewModel.ProductSheetUrl;
            inspireDataset.PresentationRulesUrl    = viewModel.PresentationRulesUrl;
            inspireDataset.ProductSpecificationUrl = viewModel.ProductSpecificationUrl;
            inspireDataset.MetadataUrl             = viewModel.MetadataUrl;
            inspireDataset.DistributionFormat      = viewModel.DistributionFormat;
            inspireDataset.DistributionUrl         = viewModel.DistributionUrl;
            inspireDataset.DistributionArea        = viewModel.DistributionArea;
            inspireDataset.WmsUrl                  = viewModel.WmsUrl;
            inspireDataset.ThemeGroupId            = viewModel.ThemeGroupId;
            inspireDataset.DatasetThumbnail        = viewModel.DatasetThumbnail;
            inspireDataset.DokStatusId             = viewModel.DokStatusId;
            inspireDataset.DokStatusDateAccepted   = viewModel.GetDateAccepted();
            inspireDataset.UuidService             = viewModel.UuidService;
            inspireDataset.Area                    = viewModel.Area;
            inspireDataset.RelevantArea            = viewModel.RelevantArea;

            if (inspireDataset.InspireDeliveryMetadata != null)
            {
                inspireDataset.InspireDeliveryMetadata.StatusId   = viewModel.MetadataStatusId;
                inspireDataset.InspireDeliveryMetadata.Note       = viewModel.MetadataNote;
                inspireDataset.InspireDeliveryMetadata.AutoUpdate = viewModel.MetadataAutoUpdate;
            }

            if (inspireDataset.InspireDeliveryMetadataService != null)
            {
                inspireDataset.InspireDeliveryMetadataService.StatusId   = viewModel.MetadataServiceStatusId;
                inspireDataset.InspireDeliveryMetadataService.Note       = viewModel.MetadataServiceNote;
                inspireDataset.InspireDeliveryMetadataService.AutoUpdate = viewModel.MetadataServiceAutoUpdate;
            }

            if (inspireDataset.InspireDeliveryDistribution != null)
            {
                inspireDataset.InspireDeliveryDistribution.StatusId   = viewModel.DistributionStatusId;
                inspireDataset.InspireDeliveryDistribution.Note       = viewModel.DistributionNote;
                inspireDataset.InspireDeliveryDistribution.AutoUpdate = viewModel.DistributionAutoUpdate;
            }

            if (inspireDataset.InspireDeliveryWms != null)
            {
                inspireDataset.InspireDeliveryWms.StatusId   = viewModel.WmsStatusId;
                inspireDataset.InspireDeliveryWms.Note       = viewModel.WmsNote;
                inspireDataset.InspireDeliveryWms.AutoUpdate = viewModel.WmsAutoUpdate;
            }

            if (inspireDataset.InspireDeliveryWfs != null)
            {
                inspireDataset.InspireDeliveryWfs.StatusId   = viewModel.WfsStatusId;
                inspireDataset.InspireDeliveryWfs.Note       = viewModel.WfsNote;
                inspireDataset.InspireDeliveryWfs.AutoUpdate = viewModel.WfsAutoUpdate;
            }

            if (inspireDataset.InspireDeliveryAtomFeed != null)
            {
                inspireDataset.InspireDeliveryAtomFeed.StatusId   = viewModel.AtomFeedStatusId;
                inspireDataset.InspireDeliveryAtomFeed.Note       = viewModel.AtomFeedNote;
                inspireDataset.InspireDeliveryAtomFeed.AutoUpdate = viewModel.AtomFeedAutoUpdate;
            }

            if (inspireDataset.InspireDeliveryWfsOrAtom != null)
            {
                inspireDataset.InspireDeliveryWfsOrAtom.StatusId   = viewModel.WfsOrAtomStatusId;
                inspireDataset.InspireDeliveryWfsOrAtom.Note       = viewModel.WfsOrAtomNote;
                inspireDataset.InspireDeliveryWfsOrAtom.AutoUpdate = viewModel.WfsOrAtomAutoUpdate;
            }

            if (inspireDataset.InspireDeliveryHarmonizedData != null)
            {
                inspireDataset.InspireDeliveryHarmonizedData.StatusId   = viewModel.HarmonizedDataStatusId;
                inspireDataset.InspireDeliveryHarmonizedData.Note       = viewModel.HarmonizedDataNote;
                inspireDataset.InspireDeliveryHarmonizedData.AutoUpdate = viewModel.HarmonizedDataAutoUpdate;
            }

            if (inspireDataset.InspireDeliverySpatialDataService != null)
            {
                inspireDataset.InspireDeliverySpatialDataService.StatusId   = viewModel.SpatialDataServiceStatusId;
                inspireDataset.InspireDeliverySpatialDataService.Note       = viewModel.SpatialDataServiceNote;
                inspireDataset.InspireDeliverySpatialDataService.AutoUpdate = viewModel.SpatialDataServiceAutoUpdate;
            }

            _dbContext.Entry(inspireDataset).State = EntityState.Modified;
            _dbContext.SaveChanges();

            return(inspireDataset);
        }
        //[Route("organisasjoner/{registerParent}/{registerowner}/{registername}/{itemowner}/{organisasjon}/rediger")]
        //[Route("organisasjoner/{registername}/{innsender}/{organisasjon}/rediger")]
        public ActionResult Edit(Organization org, HttpPostedFileBase fileSmal, HttpPostedFileBase fileLarge, string registername, string organisasjon, string registerParent, HttpPostedFileBase agreementDocument, HttpPostedFileBase priceformDocument)
        {
            var          register             = _registerService.GetRegister(registerParent, registername);
            Organization originalOrganization = (Organization)_registerItemService.GetRegisterItem(registerParent, registername, organisasjon, 1);

            ValidationName(org, register);

            if (ModelState.IsValid)
            {
                if (org.name != null)
                {
                    originalOrganization.name    = org.name;
                    originalOrganization.seoname = RegisterUrls.MakeSeoFriendlyString(org.name);
                }

                originalOrganization.shortname = org.shortname;

                if (org.submitterId != null)
                {
                    originalOrganization.submitterId = org.submitterId;
                }
                if (!string.IsNullOrEmpty(org.number))
                {
                    originalOrganization.number = org.number;
                }
                if (!string.IsNullOrEmpty(org.description))
                {
                    originalOrganization.description = org.description;
                }
                if (!string.IsNullOrEmpty(org.contact))
                {
                    originalOrganization.contact = org.contact;
                }
                if (org.statusId != null)
                {
                    originalOrganization.statusId = org.statusId;
                }
                if (fileSmal != null && fileSmal.ContentLength > 0)
                {
                    originalOrganization.logoFilename = SaveLogoOptimizedToDisk(fileSmal, org.number);
                }
                if (fileLarge != null && fileLarge.ContentLength > 0)
                {
                    originalOrganization.largeLogo = SaveLogoToDisk(fileLarge, org.number);
                }
                if (org.agreementYear != null)
                {
                    originalOrganization.agreementYear = org.agreementYear;
                }
                if (org.epost != null)
                {
                    originalOrganization.epost = org.epost;
                }
                if (org.member != null)
                {
                    originalOrganization.member = org.member;
                }
                if (org.priceFormDocument != null)
                {
                    originalOrganization.priceFormDocument = org.priceFormDocument;
                }
                if (org.statusId != null)
                {
                    if (org.statusId == "Valid" && originalOrganization.statusId != "Valid")
                    {
                        originalOrganization.dateAccepted = DateTime.Now;
                    }
                    if (originalOrganization.statusId == "Valid" && org.statusId != "Valid")
                    {
                        originalOrganization.dateAccepted = null;
                    }
                    originalOrganization.statusId = org.statusId;
                }

                string url = System.Web.Configuration.WebConfigurationManager.AppSettings["RegistryUrl"] + "data/" + Document.DataDirectory;
                if (agreementDocument != null)
                {
                    originalOrganization.agreementDocumentUrl = url + SaveFileToDisk(agreementDocument, originalOrganization);
                }

                if (priceformDocument != null)
                {
                    originalOrganization.priceFormDocument = url + SaveFileToDisk(priceformDocument, originalOrganization);
                }

                if (org.IsMunicipality())
                {
                    originalOrganization.OrganizationType  = org.OrganizationType;
                    originalOrganization.MunicipalityCode  = org.MunicipalityCode;
                    originalOrganization.BoundingBoxEast   = org.BoundingBoxEast;
                    originalOrganization.BoundingBoxNorth  = org.BoundingBoxNorth;
                    originalOrganization.BoundingBoxSouth  = org.BoundingBoxSouth;
                    originalOrganization.BoundingBoxWest   = org.BoundingBoxWest;
                    originalOrganization.GeographicCenterX = org.GeographicCenterX;
                    originalOrganization.GeographicCenterY = org.GeographicCenterY;
                }

                originalOrganization.modified = DateTime.Now;
                _translationService.UpdateTranslations(org, originalOrganization);
                _dbContext.Entry(originalOrganization).State = EntityState.Modified;
                _dbContext.SaveChanges();
                ViewbagsOrganization(org, register);

                return(Redirect(originalOrganization.GetObjectUrl()));
            }
            ViewbagsOrganization(org, register);
            return(View(originalOrganization));
        }
Ejemplo n.º 15
0
        //[Route("subregister/{registername}/{registerOwner}/{subregister}/rediger")]
        public ActionResult Edit(Models.Register register, string registername, string subregister)
        {
            var originalRegister = _registerService.GetRegister(registername, subregister);

            if (_accessControlService.Access(originalRegister))
            {
                ValidationName(register, registername);

                if (ModelState.IsValid)
                {
                    if (register.name != null)
                    {
                        originalRegister.name = register.name;
                    }
                    originalRegister.seoname = Helpers.RegisterUrls.MakeSeoFriendlyString(originalRegister.name);
                    if (register.description != null)
                    {
                        originalRegister.description = register.description;
                    }
                    if (register.ownerId != null)
                    {
                        originalRegister.ownerId = register.ownerId;
                    }
                    if (register.managerId != null)
                    {
                        originalRegister.managerId = register.managerId;
                    }
                    if (register.targetNamespace != null)
                    {
                        originalRegister.targetNamespace = register.targetNamespace;
                    }
                    originalRegister.accessId         = register.accessId;
                    originalRegister.parentRegisterId = register.parentRegisterId;


                    originalRegister.modified = DateTime.Now;
                    if (register.statusId != null)
                    {
                        originalRegister.statusId = register.statusId;
                        if (originalRegister.statusId != "Valid" && register.statusId == "Valid")
                        {
                            originalRegister.dateAccepted = DateTime.Now;
                        }

                        if (originalRegister.statusId == "Valid" && register.statusId != "Valid")
                        {
                            originalRegister.dateAccepted = null;
                        }
                    }

                    originalRegister.MakeAllItemsValid = register.MakeAllItemsValid;
                    if (originalRegister.MakeAllItemsValid)
                    {
                        _registerItemService.MakeAllRegisterItemsValid(originalRegister);
                    }
                    _translationService.UpdateTranslations(register, originalRegister);
                    _db.Entry(originalRegister).State = EntityState.Modified;
                    _db.SaveChanges();
                    Viewbags(register);

                    return(Redirect(originalRegister.GetObjectUrl()));
                }
            }
            else
            {
                throw new HttpException(401, "Access Denied");
            }

            Viewbags(register);
            return(View(originalRegister));
        }
        public ActionResult Edit(string systemId, string ownerId, string responsibleId, GeoDataCollection collection, HttpPostedFileBase imagefile)
        {
            try
            {
                var sanitizer = new HtmlSanitizer();

                var geodataCollection = _dbContext.GeoDataCollections.Where(g => g.systemId.ToString() == systemId).FirstOrDefault();

                if (!(User.IsInRole(GeonorgeRoles.MetadataAdmin) || (User.IsInRole(GeonorgeRoles.MetadataEditor) && geodataCollection.Owner == ClaimsPrincipal.Current.GetOrganizationName())))
                {
                    new HttpUnauthorizedResult();
                }

                geodataCollection.Title     = sanitizer.Sanitize(collection.Title);
                geodataCollection.SeoName   = RegisterUrls.MakeSeoFriendlyString(sanitizer.Sanitize(collection.Title));
                geodataCollection.Link      = sanitizer.Sanitize(collection.Link);
                geodataCollection.LinkLabel = sanitizer.Sanitize(collection.LinkLabel);
                geodataCollection.Purpose   = sanitizer.Sanitize(collection.Purpose);

                geodataCollection.DatasetTitle                 = sanitizer.Sanitize(collection.DatasetTitle);
                geodataCollection.DatasetLink                  = sanitizer.Sanitize(collection.DatasetLink);
                geodataCollection.Mapper                       = sanitizer.Sanitize(collection.Mapper);
                geodataCollection.DataOwner                    = sanitizer.Sanitize(collection.DataOwner);
                geodataCollection.Distributor                  = sanitizer.Sanitize(collection.Distributor);
                geodataCollection.Methodology                  = sanitizer.Sanitize(collection.Methodology);
                geodataCollection.ProcessHistory               = sanitizer.Sanitize(collection.ProcessHistory);
                geodataCollection.ProcessHistoryLabel          = sanitizer.Sanitize(collection.ProcessHistoryLabel);
                geodataCollection.RegistrationRequirements     = sanitizer.Sanitize(collection.RegistrationRequirements);
                geodataCollection.MappingRequirements          = sanitizer.Sanitize(collection.MappingRequirements);
                geodataCollection.MappingRequirementsLink      = sanitizer.Sanitize(collection.MappingRequirementsLink);
                geodataCollection.MappingRequirementsLinkLabel = sanitizer.Sanitize(collection.MappingRequirementsLinkLabel);
                geodataCollection.MethodologyDocumentLink      = sanitizer.Sanitize(collection.MethodologyDocumentLink);
                geodataCollection.MethodologyLinkWebPage       = sanitizer.Sanitize(collection.MethodologyLinkWebPage);
                geodataCollection.SupportSchemes               = sanitizer.Sanitize(collection.SupportSchemes);

                geodataCollection.OtherOrganizationsInvolved = sanitizer.Sanitize(collection.OtherOrganizationsInvolved);
                geodataCollection.LinkToMapSolution          = sanitizer.Sanitize(collection.LinkToMapSolution);
                geodataCollection.LinkToMapSolutionLabel     = sanitizer.Sanitize(collection.LinkToMapSolutionLabel);
                geodataCollection.LinkInfoPage          = sanitizer.Sanitize(collection.LinkInfoPage);
                geodataCollection.LinkInfoPageLabel     = sanitizer.Sanitize(collection.LinkInfoPageLabel);
                geodataCollection.LinkOtherInfo         = sanitizer.Sanitize(collection.LinkOtherInfo);
                geodataCollection.OtherInfo             = sanitizer.Sanitize(collection.OtherInfo);
                geodataCollection.AidAndSubsidies       = sanitizer.Sanitize(collection.AidAndSubsidies);
                geodataCollection.MethodForMappingShort = sanitizer.Sanitize(collection.MethodForMappingShort);
                geodataCollection.OtherWebInfoAboutMappingMethodology      = sanitizer.Sanitize(collection.OtherWebInfoAboutMappingMethodology);
                geodataCollection.OtherWebInfoAboutMappingMethodologyLabel = sanitizer.Sanitize(collection.OtherWebInfoAboutMappingMethodologyLabel);
                geodataCollection.LinkToRequirementsForDelivery            = sanitizer.Sanitize(collection.LinkToRequirementsForDelivery);
                geodataCollection.LinkToRequirementsForDeliveryLabel       = sanitizer.Sanitize(collection.LinkToRequirementsForDeliveryLabel);
                geodataCollection.OrganizationInfo = sanitizer.Sanitize(collection.OrganizationInfo);
                geodataCollection.ContactEmail     = sanitizer.Sanitize(collection.ContactEmail);

                var org = _dbContext.Organizations.Where(o => o.systemId.ToString() == ownerId).FirstOrDefault();
                geodataCollection.Organization = org;

                var responsible = _dbContext.Organizations.Where(o => o.systemId.ToString() == responsibleId).FirstOrDefault();
                if (responsible != null)
                {
                    geodataCollection.Responsible = responsible;
                }

                if (imagefile != null && imagefile.ContentLength > 0)
                {
                    geodataCollection.ThumbnailFileName = SaveImageOptimizedToDisk(imagefile, geodataCollection.SeoName);

                    geodataCollection.ImageFileName = SaveImageToDisk(imagefile, geodataCollection.SeoName);
                }


                _dbContext.Entry(geodataCollection).State = EntityState.Modified;
                _dbContext.SaveChanges();

                ViewBag.ownerId = new SelectList(_dbContext.Organizations.ToList().Select(s => new { s.systemId, name = s.NameTranslated() }).OrderBy(s => s.name), "systemId", "name", geodataCollection.Organization.systemId);

                return(RedirectToAction("Index"));
            }
            catch
            {
                return(View());
            }
        }
Ejemplo n.º 17
0
        //[Route("subregister/{registername}/{registerOwner}/{subregister}/rediger")]
        public ActionResult Edit(Models.Register register, string registername, DateTime?itemsValidFrom, DateTime?itemsValidTo)
        {
            var originalRegister = _registerService.GetRegisterBySystemId(register.systemId);

            if (_accessControlService.HasAccessTo(originalRegister))
            {
                ValidationName(register, originalRegister);

                if (ModelState.IsValid)
                {
                    if (register.name != null)
                    {
                        originalRegister.name = register.name;
                    }
                    originalRegister.seoname = Helpers.RegisterUrls.MakeSeoFriendlyString(originalRegister.name, register.TransliterNorwegian);
                    var pathOld = originalRegister.path;
                    var transliterNorwegianOld = originalRegister.TransliterNorwegian;
                    originalRegister.path = RegisterUrls.GetNewPath(originalRegister.path, originalRegister.seoname);
                    if (register.description != null)
                    {
                        originalRegister.description = register.description;
                    }
                    if (register.ownerId != null)
                    {
                        originalRegister.ownerId = register.ownerId;
                    }
                    if (register.managerId != null)
                    {
                        originalRegister.managerId = register.managerId;
                    }
                    if (register.targetNamespace != null)
                    {
                        originalRegister.targetNamespace = register.targetNamespace;
                    }
                    originalRegister.accessId         = register.accessId;
                    originalRegister.parentRegisterId = register.parentRegisterId;


                    originalRegister.modified = DateTime.Now;
                    if (register.statusId != null)
                    {
                        originalRegister.statusId = register.statusId;
                        if (originalRegister.statusId != "Valid" && register.statusId == "Valid")
                        {
                            originalRegister.dateAccepted = DateTime.Now;
                        }

                        if (originalRegister.statusId == "Valid" && register.statusId != "Valid")
                        {
                            originalRegister.dateAccepted = null;
                        }
                    }

                    originalRegister.MakeAllItemsValid = register.MakeAllItemsValid;
                    if (originalRegister.MakeAllItemsValid)
                    {
                        _registerItemService.MakeAllRegisterItemsValid(originalRegister, itemsValidFrom, itemsValidTo);
                    }
                    originalRegister.MakeAllItemsRetired = register.MakeAllItemsRetired;
                    if (originalRegister.MakeAllItemsRetired)
                    {
                        _registerItemService.MakeAllRegisterItemsRetired(originalRegister);
                    }
                    originalRegister.MakeAllItemsDraft = register.MakeAllItemsDraft;
                    if (originalRegister.MakeAllItemsDraft)
                    {
                        _registerItemService.MakeAllRegisterItemsDraft(originalRegister);
                    }
                    originalRegister.TransliterNorwegian = register.TransliterNorwegian;
                    _translationService.UpdateTranslations(register, originalRegister);
                    _db.Entry(originalRegister).State = EntityState.Modified;
                    _db.SaveChanges();

                    if (pathOld != originalRegister.path || transliterNorwegianOld != originalRegister.TransliterNorwegian)
                    {
                        new SynchronizationService(_db).UpdatePaths(originalRegister.systemId.ToString(), originalRegister.TransliterNorwegian);
                    }

                    Viewbags(register);

                    return(Redirect(originalRegister.GetObjectUrl()));
                }
            }
            else
            {
                throw new HttpException(401, "Access Denied");
            }

            Viewbags(register);
            return(View(originalRegister));
        }
Ejemplo n.º 18
0
 public void UpdateTranslations(Models.Register register, Models.Register originalRegister)
 {
     originalRegister.Translations.Where(t => t.RegisterId != Guid.Empty).ToList().ForEach(x => _dbContext.Entry(x).State = EntityState.Deleted);
     originalRegister.Translations = register.Translations;
 }
        public MareanoDataset UpdateMareanoDataset(MareanoDatasetViewModel viewModel)
        {
            var MareanoDataset = GetMareanoDatasetBySystemId(viewModel.SystemId);

            MareanoDataset.Name          = viewModel.Name;
            MareanoDataset.Seoname       = RegisterUrls.MakeSeoFriendlyString(MareanoDataset.Name);
            MareanoDataset.Description   = viewModel.Description;
            MareanoDataset.SubmitterId   = viewModel.SubmitterId;
            MareanoDataset.OwnerId       = viewModel.OwnerId;
            MareanoDataset.Modified      = DateTime.Now;
            MareanoDataset.DateSubmitted = DateTime.Now;
            MareanoDataset.RegisterId    = viewModel.RegisterId;

            MareanoDataset.Uuid                    = viewModel.Uuid;
            MareanoDataset.Notes                   = viewModel.Notes;
            MareanoDataset.SpecificUsage           = viewModel.SpecificUsage;
            MareanoDataset.ProductSheetUrl         = viewModel.ProductSheetUrl;
            MareanoDataset.PresentationRulesUrl    = viewModel.PresentationRulesUrl;
            MareanoDataset.ProductSpecificationUrl = viewModel.ProductSpecificationUrl;
            MareanoDataset.MetadataUrl             = viewModel.MetadataUrl;
            MareanoDataset.DistributionFormat      = viewModel.DistributionFormat;
            MareanoDataset.DistributionUrl         = viewModel.DistributionUrl;
            MareanoDataset.DistributionArea        = viewModel.DistributionArea;
            MareanoDataset.WmsUrl                  = viewModel.WmsUrl;
            MareanoDataset.ThemeGroupId            = viewModel.ThemeGroupId;
            MareanoDataset.DatasetThumbnail        = viewModel.DatasetThumbnail;
            MareanoDataset.DokStatusId             = viewModel.DokStatusId;
            MareanoDataset.DokStatusDateAccepted   = viewModel.GetDateAccepted();
            MareanoDataset.UuidService             = viewModel.UuidService;

            if (MareanoDataset.MetadataStatus != null)
            {
                MareanoDataset.MetadataStatus.StatusId   = viewModel.MetadataStatusId;
                MareanoDataset.MetadataStatus.Note       = viewModel.MetadataNote;
                MareanoDataset.MetadataStatus.AutoUpdate = viewModel.MetadataAutoUpdate;
            }

            if (MareanoDataset.ProductSpesificationStatus != null)
            {
                MareanoDataset.ProductSpesificationStatus.StatusId   = viewModel.ProductSpesificationStatusId;
                MareanoDataset.ProductSpesificationStatus.Note       = viewModel.ProduktspesifikasjonNote;
                MareanoDataset.ProductSpesificationStatus.AutoUpdate = viewModel.ProduktspesifikasjonAutoUpdate;
            }

            if (MareanoDataset.SosiDataStatus != null)
            {
                MareanoDataset.SosiDataStatus.StatusId   = viewModel.SosiDataStatusId;
                MareanoDataset.SosiDataStatus.Note       = viewModel.SosiDataNote;
                MareanoDataset.SosiDataStatus.AutoUpdate = viewModel.SosiDataAutoUpdate;
            }

            if (MareanoDataset.GmlDataStatus != null)
            {
                MareanoDataset.GmlDataStatus.StatusId   = viewModel.GmlDataStatusId;
                MareanoDataset.GmlDataStatus.Note       = viewModel.GmlDataNote;
                MareanoDataset.GmlDataStatus.AutoUpdate = viewModel.GmlDataAutoUpdate;
            }

            if (MareanoDataset.WmsStatus != null)
            {
                MareanoDataset.WmsStatus.StatusId   = viewModel.WmsStatusId;
                MareanoDataset.WmsStatus.Note       = viewModel.WmsNote;
                MareanoDataset.WmsStatus.AutoUpdate = viewModel.WmsAutoUpdate;
            }

            if (MareanoDataset.WfsStatus != null)
            {
                MareanoDataset.WfsStatus.StatusId   = viewModel.WfsStatusId;
                MareanoDataset.WfsStatus.Note       = viewModel.WfsNote;
                MareanoDataset.WfsStatus.AutoUpdate = viewModel.WfsAutoUpdate;
            }

            if (MareanoDataset.AtomFeedStatus != null)
            {
                MareanoDataset.AtomFeedStatus.StatusId   = viewModel.AtomFeedStatusId;
                MareanoDataset.AtomFeedStatus.Note       = viewModel.AtomFeedNote;
                MareanoDataset.AtomFeedStatus.AutoUpdate = viewModel.AtomFeedAutoUpdate;
            }

            if (MareanoDataset.CommonStatus != null)
            {
                MareanoDataset.CommonStatus.StatusId   = viewModel.CommonStatusId;
                MareanoDataset.CommonStatus.Note       = viewModel.CommonNote;
                MareanoDataset.CommonStatus.AutoUpdate = viewModel.CommonAutoUpdate;
            }

            _dbContext.Entry(MareanoDataset).State = EntityState.Modified;
            _dbContext.SaveChanges();

            return(MareanoDataset);
        }