private static void MakeSeoFriendlyDocumentName(HttpPostedFileBase file, out string filtype, out string seofilename)
{
string[] documentfilename = file.FileName.Split('.');
filtype = documentfilename.Last();
seofilename = null;
foreach (string item in documentfilename)
{
if (item == filtype)
{
break;
}
seofilename += RegisterUrls.MakeSeoFriendlyString(item) + "_";
}
}
public MareanoDataset NewMareanoDataset(MareanoDatasetViewModel MareanoViewModel, string parentregister, string registername)
{
var MareanoDataset = new MareanoDataset();
MareanoDataset.SystemId = Guid.NewGuid();
MareanoDataset.Name = MareanoViewModel.Name;
MareanoDataset.Seoname = RegisterUrls.MakeSeoFriendlyString(MareanoDataset.Name);
MareanoDataset.Description = MareanoViewModel.Description;
MareanoDataset.SubmitterId = _registerService.GetOrganizationIdByUserName();
MareanoDataset.OwnerId = MareanoViewModel.OwnerId;
MareanoDataset.DateSubmitted = DateTime.Now;
MareanoDataset.Modified = DateTime.Now;
MareanoDataset.RegisterId = _registerService.GetRegisterId(parentregister, registername);
MareanoDataset.VersioningId = _registerItemService.NewVersioningGroup(MareanoDataset);
MareanoDataset.VersionNumber = 1;
MareanoDataset.StatusId = "Submitted";
MareanoDataset.Uuid = MareanoViewModel.Uuid;
MareanoDataset.Notes = MareanoViewModel.Notes;
MareanoDataset.SpecificUsage = MareanoViewModel.SpecificUsage;
MareanoDataset.ProductSheetUrl = MareanoViewModel.ProductSheetUrl;
MareanoDataset.PresentationRulesUrl = MareanoViewModel.PresentationRulesUrl;
MareanoDataset.ProductSpecificationUrl = MareanoViewModel.ProductSpecificationUrl;
MareanoDataset.MetadataUrl = MareanoViewModel.MetadataUrl;
MareanoDataset.DistributionFormat = MareanoViewModel.DistributionFormat;
MareanoDataset.DistributionUrl = MareanoViewModel.DistributionUrl;
MareanoDataset.DistributionArea = MareanoViewModel.DistributionArea;
MareanoDataset.WmsUrl = MareanoViewModel.WmsUrl;
MareanoDataset.ThemeGroupId = MareanoViewModel.ThemeGroupId;
MareanoDataset.DatasetThumbnail = MareanoViewModel.DatasetThumbnail;
MareanoDataset.DokStatusId = "Proposal";
MareanoDataset.UuidService = MareanoViewModel.UuidService;
GetDeliveryStatuses(MareanoViewModel, MareanoDataset);
MareanoDataset.MetadataStatusId = _datasetDeliveryService.CreateDatasetDelivery(MareanoViewModel.MetadataStatusId, MareanoViewModel.MetadataNote);
MareanoDataset.ProductSpesificationStatusId = _datasetDeliveryService.CreateDatasetDelivery(MareanoViewModel.WmsStatusId, MareanoViewModel.WmsNote);
MareanoDataset.SosiDataStatusId = _datasetDeliveryService.CreateDatasetDelivery(MareanoViewModel.WmsStatusId, MareanoViewModel.WmsNote);
MareanoDataset.GmlDataStatusId = _datasetDeliveryService.CreateDatasetDelivery(MareanoViewModel.WmsStatusId, MareanoViewModel.WmsNote);
MareanoDataset.WmsStatusId = _datasetDeliveryService.CreateDatasetDelivery(MareanoViewModel.WmsStatusId, MareanoViewModel.WmsNote);
MareanoDataset.WfsStatusId = _datasetDeliveryService.CreateDatasetDelivery(MareanoViewModel.WfsStatusId, MareanoViewModel.WfsNote);
MareanoDataset.AtomFeedStatusId = _datasetDeliveryService.CreateDatasetDelivery(MareanoViewModel.AtomFeedStatusId, MareanoViewModel.AtomFeedNote);
MareanoDataset.CommonStatusId = _datasetDeliveryService.CreateDatasetDelivery(MareanoViewModel.WmsStatusId, MareanoViewModel.WmsNote);
MareanoDataset.Grade = GetGrade(MareanoDataset);
_dbContext.MareanoDatasets.Add(MareanoDataset);
_dbContext.SaveChanges();
return(MareanoDataset);
}
private Dataset NewDataset(string name)
{
Dataset dataset = new Dataset();
dataset.systemId = Guid.NewGuid();
dataset.name = name;
dataset.seoname = RegisterUrls.MakeSeoFriendlyString(dataset.name);
dataset.description = "testbeskrivelse";
dataset.datasetowner = NewOrganization("Testorg");
dataset.datasetownerId = dataset.datasetowner.systemId;
dataset.submitter = dataset.datasetowner;
dataset.submitterId = dataset.submitterId;
dataset.versionNumber = 1;
dataset.register = NewRegister("DOK-statusregisteret");
return(dataset);
}
private void NewMareanoDatasetFromKartkatalogen(MareanoDataset MareanoDataset)
{
if (!_registerItemService.ItemNameIsValid(MareanoDataset))
{
return;
}
MareanoDataset.SystemId = Guid.NewGuid();
MareanoDataset.Seoname = RegisterUrls.MakeSeoFriendlyString(MareanoDataset.Name);
MareanoDataset.SubmitterId = _registerService.GetOrganizationIdByUserName();
MareanoDataset.DateSubmitted = DateTime.Now;
MareanoDataset.Modified = DateTime.Now;
MareanoDataset.RegisterId = _registerService.GetMareanoStatusRegisterId();
MareanoDataset.VersioningId = _registerItemService.NewVersioningGroup(MareanoDataset);
MareanoDataset.VersionNumber = 1;
MareanoDataset.StatusId = "Submitted";
MareanoDataset.DokStatusId = "Proposal";
var metadataStatusId = _datasetDeliveryService.GetMetadataStatus(MareanoDataset.Uuid);
var productSpesificationStatusId = _registerService.GetDOKStatus(MareanoDataset.ProductSpecificationUrl, true, "deficient");
var productSheetStatusId = _registerService.GetDOKStatus(MareanoDataset.ProductSheetUrl, true, "deficient");
var presentationRulesStatusId = _registerService.GetDOKStatus(MareanoDataset.PresentationRulesUrl, true, "deficient");
var sosiDataStatusId = _registerService.GetSosiRequirements(MareanoDataset.Uuid, "", true, "deficient");
var gmlDataStatusId = _registerService.GetGmlRequirements(MareanoDataset.Uuid, true, "deficient");
var wmsStatusId = _datasetDeliveryService.GetDokDeliveryServiceStatus(MareanoDataset.Uuid, true, "deficient", MareanoDataset.UuidService);
var wfsStatusId = _datasetDeliveryService.GetWfsStatus(MareanoDataset.Uuid);
var atomFeedStatusId = _datasetDeliveryService.GetAtomFeedStatus(MareanoDataset.Uuid);
var commonStatusId = _datasetDeliveryService.GetDownloadRequirementsStatus(wfsStatusId, atomFeedStatusId);
MareanoDataset.MetadataStatusId = _datasetDeliveryService.CreateDatasetDelivery(metadataStatusId);
MareanoDataset.ProductSpesificationStatusId = _datasetDeliveryService.CreateDatasetDelivery(productSpesificationStatusId);
MareanoDataset.ProductSheetStatusId = _datasetDeliveryService.CreateDatasetDelivery(productSheetStatusId);
MareanoDataset.PresentationRulesStatusId = _datasetDeliveryService.CreateDatasetDelivery(presentationRulesStatusId);
MareanoDataset.SosiDataStatusId = _datasetDeliveryService.CreateDatasetDelivery(sosiDataStatusId);
MareanoDataset.GmlDataStatusId = _datasetDeliveryService.CreateDatasetDelivery(gmlDataStatusId);
MareanoDataset.WmsStatusId = _datasetDeliveryService.CreateDatasetDelivery(wmsStatusId);
MareanoDataset.WfsStatusId = _datasetDeliveryService.CreateDatasetDelivery(wfsStatusId);
MareanoDataset.AtomFeedStatusId = _datasetDeliveryService.CreateDatasetDelivery(atomFeedStatusId);
MareanoDataset.CommonStatusId = _datasetDeliveryService.CreateDatasetDelivery(commonStatusId);
MareanoDataset.Grade = GetGrade(MareanoDataset);
SetFAIR(ref MareanoDataset);
_dbContext.MareanoDatasets.Add(MareanoDataset);
_dbContext.SaveChanges();
}
// **** HJELPEMETODER ****
private Models.Register NewRegister(string name)
{
Models.Register register = new Models.Register();
register.systemId = Guid.NewGuid();
register.name = name;
register.seoname = RegisterUrls.MakeSeoFriendlyString(register.name);
register.description = "testbeskrivelse";
register.status = new Status {
value = "Valid", description = "Gyldig"
};
register.owner = NewOrganization("Testorg");
register.Translations.Add(new Models.Translations.RegisterTranslation {
CultureName = Culture.NorwegianCode
});
register.AddMissingTranslations();
return(register);
}
private void NewInspireDatasetFromKartkatalogen(InspireDataset inspireDataset, Synchronize synchronizationJob)
{
if (!_registerItemService.ItemNameIsValid(inspireDataset))
{
synchronizationJob.FailCount++;
synchronizationJob.FailLog.Add(new SyncLogEntry(inspireDataset, "Navn finnes fra før"));
return;
}
inspireDataset.SystemId = Guid.NewGuid();
inspireDataset.Seoname = RegisterUrls.MakeSeoFriendlyString(inspireDataset.Name);
inspireDataset.SubmitterId = _registerService.GetOrganizationIdByUserName();
inspireDataset.DateSubmitted = DateTime.Now;
inspireDataset.Modified = DateTime.Now;
inspireDataset.RegisterId = _registerService.GetInspireStatusRegisterId();
inspireDataset.VersioningId = _registerItemService.NewVersioningGroup(inspireDataset);
inspireDataset.VersionNumber = 1;
inspireDataset.StatusId = "Submitted";
inspireDataset.DokStatusId = "Proposal";
//GetDeliveryStatuses(inspireDatasetViewModel, inspireDataset);
var metadataStatus = _datasetDeliveryService.GetMetadataStatus(inspireDataset.Uuid);
var metadataServiceStatus = "good";
var distributionStatus = _datasetDeliveryService.GetDeliveryDistributionStatus(inspireDataset.Uuid, inspireDataset.DistributionUrl);
var wmsStatus = _datasetDeliveryService.GetInspireWmsStatus(inspireDataset.Uuid, true, "deficient", inspireDataset.UuidService);
var wfsStatus = _datasetDeliveryService.GetInspireWfsStatus(inspireDataset.Uuid);
var atomFeedStatus = _datasetDeliveryService.GetAtomFeedStatus(inspireDataset.Uuid);
var wfsOrAtomStatus = _datasetDeliveryService.GetDownloadRequirementsStatus(wfsStatus, atomFeedStatus);
var harmonizedDataStatus = _datasetDeliveryService.GetHarmonizedStatus(inspireDataset.Uuid);
var spatialDataServiceStatusId = _datasetDeliveryService.GetSpatialDataStatus(inspireDataset.Uuid);
inspireDataset.InspireDeliveryMetadataId = _datasetDeliveryService.CreateDatasetDelivery(metadataStatus);
inspireDataset.InspireDeliveryMetadataServiceId = _datasetDeliveryService.CreateDatasetDelivery(metadataServiceStatus);
inspireDataset.InspireDeliveryDistributionId = _datasetDeliveryService.CreateDatasetDelivery(distributionStatus);
inspireDataset.InspireDeliveryWmsId = _datasetDeliveryService.CreateDatasetDelivery(wmsStatus);
inspireDataset.InspireDeliveryWfsId = _datasetDeliveryService.CreateDatasetDelivery(wfsStatus);
inspireDataset.InspireDeliveryAtomFeedId = _datasetDeliveryService.CreateDatasetDelivery(atomFeedStatus);
inspireDataset.InspireDeliveryWfsOrAtomId = _datasetDeliveryService.CreateDatasetDelivery(wfsOrAtomStatus);
inspireDataset.InspireDeliveryHarmonizedDataId = _datasetDeliveryService.CreateDatasetDelivery(harmonizedDataStatus);
inspireDataset.InspireDeliverySpatialDataServiceId = _datasetDeliveryService.CreateDatasetDelivery(spatialDataServiceStatusId);
synchronizationJob.AddedLog.Add(new SyncLogEntry(inspireDataset, "Lagt til"));
_dbContext.InspireDatasets.Add(inspireDataset);
_dbContext.SaveChanges();
}
public void Update(Document document)
{
systemId = document.systemId;
name = document.name;
seoname = RegisterUrls.MakeSeoFriendlyString(name);
modified = DateTime.Now;
description = document.description;
approvalDocument = document.approvalDocument;
approvalReference = document.approvalReference;
ApplicationSchema = document.ApplicationSchema;
GMLApplicationSchema = document.GMLApplicationSchema;
CartographyFile = document.CartographyFile;
CartographyDetailsUrl = document.CartographyDetailsUrl;
versionName = document.versionName;
versionNumber = document.versionNumber;
Accepted = document.Accepted;
documentownerId = document.documentownerId;
submitterId = document.submitterId;
versioningId = document.versioningId;
}
//[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());
}
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);
}
public IHttpActionResult GetRegisterByName(string registerName, [FromUri] FilterParameters filter = null)
{
var register = _registerService.GetRegisterByName(registerName);
if (register != null)
{
if (filter != null && !string.IsNullOrEmpty(filter.filterOrganization))
{
filter.filterOrganization = RegisterUrls.MakeSeoFriendlyString(filter.filterOrganization);
}
int totalNumberOfItems = GetTotalNumberOfCurrentItemsByOrganization(filter, register);
if (filter != null && !string.IsNullOrEmpty(filter.filterOrganization) && register.IsDokStatusRegister())
{
totalNumberOfItems = register.items.OfType <Dataset>().Where(o => o.datasetowner.seoname.ToLower() == filter.filterOrganization.ToLower()).Count();
}
if (filter != null || register.IsDokMunicipal())
{
register = RegisterItems(register, filter);
}
var result = ConvertRegisterAndNextLevel(register, filter);
result.ContainedItemsResult.Total = totalNumberOfItems;
if (filter != null)
{
result.ContainedItemsResult.Limit = filter.Limit;
result.ContainedItemsResult.Offset = filter.Offset;
}
return(Ok(result));
}
return(NotFound());
}
private List <RegisterItem> GetListOfVersions(string versionName, Models.Register register, string Owner)
{
Models.Version versionGroup = new Models.Version();
versionGroup.systemId = Guid.NewGuid();
versionGroup.lastVersionNumber = 0;
List <Models.RegisterItem> versions = new List <Models.RegisterItem>();
for (int i = 0; i < 5; i++)
{
Document document = new Document();
document.systemId = Guid.NewGuid();
document.name = versionName;
document.seoname = RegisterUrls.MakeSeoFriendlyString(document.name);
Organization organisasjon = NewOrganization(Owner);
document.documentowner = organisasjon;
document.submitter = organisasjon;
document.versionNumber = versionGroup.lastVersionNumber;
document.versioning = versionGroup;
document.versioningId = versionGroup.systemId;
document.register = register;
document.Translations.Add(new Models.Translations.DocumentTranslation {
CultureName = Culture.NorwegianCode
});
document.AddMissingTranslations();
versions.Add(document);
versionGroup.lastVersionNumber++;
}
versionGroup.currentVersion = versions[0].systemId;
foreach (Models.RegisterItem doc in versions)
{
doc.versioning.currentVersion = versionGroup.currentVersion;
}
return(versions);
}
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);
}
/// <summary>
/// Make SEO friendly name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private string DocumentSeoName(string name)
{
return(RegisterUrls.MakeSeoFriendlyString(name));
}
private MareanoDataset UpdateMareanoDataset(MareanoDataset originalDataset, MareanoDataset MareanoDatasetFromKartkatalogen)
{
originalDataset.Name = MareanoDatasetFromKartkatalogen.Name;
originalDataset.Seoname = RegisterUrls.MakeSeoFriendlyString(originalDataset.Name);
originalDataset.Description = MareanoDatasetFromKartkatalogen.Description;
originalDataset.OwnerId = MareanoDatasetFromKartkatalogen.OwnerId;
originalDataset.Modified = DateTime.Now;
originalDataset.Uuid = MareanoDatasetFromKartkatalogen.Uuid;
originalDataset.Notes = MareanoDatasetFromKartkatalogen.Notes;
originalDataset.SpecificUsage = MareanoDatasetFromKartkatalogen.SpecificUsage;
originalDataset.ProductSheetUrl = MareanoDatasetFromKartkatalogen.ProductSheetUrl;
originalDataset.PresentationRulesUrl = MareanoDatasetFromKartkatalogen.PresentationRulesUrl;
originalDataset.ProductSpecificationUrl = MareanoDatasetFromKartkatalogen.ProductSpecificationUrl;
originalDataset.MetadataUrl = MareanoDatasetFromKartkatalogen.MetadataUrl;
originalDataset.DistributionFormat = MareanoDatasetFromKartkatalogen.DistributionFormat;
originalDataset.DistributionUrl = MareanoDatasetFromKartkatalogen.DistributionUrl;
originalDataset.DistributionArea = MareanoDatasetFromKartkatalogen.DistributionArea;
originalDataset.WmsUrl = MareanoDatasetFromKartkatalogen.WmsUrl;
originalDataset.ThemeGroupId = MareanoDatasetFromKartkatalogen.ThemeGroupId;
originalDataset.DatasetThumbnail = MareanoDatasetFromKartkatalogen.DatasetThumbnail;
originalDataset.UuidService = MareanoDatasetFromKartkatalogen.UuidService;
if (originalDataset.MetadataStatus != null)
{
originalDataset.MetadataStatus.StatusId = _datasetDeliveryService.GetMetadataStatus(MareanoDatasetFromKartkatalogen.Uuid, true, originalDataset.MetadataStatus.StatusId);
}
if (originalDataset.ProductSpesificationStatus != null)
{
originalDataset.ProductSpesificationStatus.StatusId = _registerService.GetDOKStatus(MareanoDatasetFromKartkatalogen.ProductSpecificationUrl, true, originalDataset.ProductSpesificationStatus.StatusId);
}
if (originalDataset.ProductSheetStatus == null)
{
originalDataset.ProductSheetStatus = CreateDatasetDelivery("notset", null, true);
}
if (originalDataset.PresentationRulesStatus == null)
{
originalDataset.PresentationRulesStatus = CreateDatasetDelivery("notset", null, true);
}
if (originalDataset.ProductSheetStatus != null)
{
originalDataset.ProductSheetStatus.StatusId = _registerService.GetDOKStatus(MareanoDatasetFromKartkatalogen.ProductSheetUrl, true, originalDataset.ProductSheetStatus.StatusId);
}
if (originalDataset.PresentationRulesStatus != null)
{
originalDataset.PresentationRulesStatus.StatusId = _registerService.GetDOKStatus(MareanoDatasetFromKartkatalogen.PresentationRulesUrl, true, originalDataset.PresentationRulesStatus.StatusId);
}
if (originalDataset.SosiDataStatus != null)
{
originalDataset.SosiDataStatus.StatusId = _registerService.GetSosiRequirements(MareanoDatasetFromKartkatalogen.Uuid, originalDataset.ProductSpecificationUrl, true, originalDataset.SosiDataStatus.StatusId);
}
if (originalDataset.GmlDataStatus != null)
{
originalDataset.GmlDataStatus.StatusId = _registerService.GetGmlRequirements(MareanoDatasetFromKartkatalogen.Uuid, true, originalDataset.GmlDataStatus.StatusId);
}
if (originalDataset.WmsStatus != null)
{
originalDataset.WmsStatus.StatusId = _datasetDeliveryService.GetDokDeliveryServiceStatus(MareanoDatasetFromKartkatalogen.Uuid, true, originalDataset.WmsStatus.StatusId, MareanoDatasetFromKartkatalogen.UuidService);
}
if (originalDataset.WfsStatus != null)
{
originalDataset.WfsStatus.StatusId = _datasetDeliveryService.GetWfsStatus(MareanoDatasetFromKartkatalogen.Uuid, true, originalDataset.WfsStatus.StatusId, MareanoDatasetFromKartkatalogen.UuidService);
}
if (originalDataset.AtomFeedStatus != null)
{
originalDataset.AtomFeedStatus.StatusId = _datasetDeliveryService.GetAtomFeedStatus(MareanoDatasetFromKartkatalogen.Uuid, true, originalDataset.AtomFeedStatus.StatusId);
}
if (originalDataset.CommonStatus != null)
{
originalDataset.CommonStatus.StatusId = _datasetDeliveryService.GetDownloadRequirementsStatus(originalDataset.WfsStatus?.StatusId, originalDataset.AtomFeedStatus?.StatusId);
}
originalDataset.Grade = GetGrade(originalDataset);
SetFAIR(ref originalDataset);
_dbContext.Entry(originalDataset).State = EntityState.Modified;
_dbContext.SaveChanges();
return(originalDataset);
}
public InspireDataset UpdateInspireDataset(InspireDataset originalDataset, InspireDataset inspireDatasetFromKartkatalogen, Synchronize synchronizationJob = null)
{
originalDataset.Name = inspireDatasetFromKartkatalogen.Name;
originalDataset.Seoname = RegisterUrls.MakeSeoFriendlyString(originalDataset.Name);
originalDataset.Description = inspireDatasetFromKartkatalogen.Description;
originalDataset.OwnerId = inspireDatasetFromKartkatalogen.OwnerId;
originalDataset.Modified = DateTime.Now;
originalDataset.Uuid = inspireDatasetFromKartkatalogen.Uuid;
originalDataset.SpecificUsage = inspireDatasetFromKartkatalogen.SpecificUsage;
originalDataset.ProductSheetUrl = inspireDatasetFromKartkatalogen.ProductSheetUrl;
originalDataset.PresentationRulesUrl = inspireDatasetFromKartkatalogen.PresentationRulesUrl;
originalDataset.ProductSpecificationUrl = inspireDatasetFromKartkatalogen.ProductSpecificationUrl;
originalDataset.MetadataUrl = inspireDatasetFromKartkatalogen.MetadataUrl;
originalDataset.DistributionFormat = inspireDatasetFromKartkatalogen.DistributionFormat;
originalDataset.DistributionUrl = inspireDatasetFromKartkatalogen.DistributionUrl;
originalDataset.DistributionArea = inspireDatasetFromKartkatalogen.DistributionArea;
originalDataset.WmsUrl = inspireDatasetFromKartkatalogen.WmsUrl;
originalDataset.ThemeGroupId = inspireDatasetFromKartkatalogen.ThemeGroupId;
originalDataset.DatasetThumbnail = inspireDatasetFromKartkatalogen.DatasetThumbnail;
originalDataset.UuidService = inspireDatasetFromKartkatalogen.UuidService;
originalDataset.UpdateInspireTheme(inspireDatasetFromKartkatalogen.InspireThemes);
DatasetDeliveryService d = new DatasetDeliveryService(synchronizationJob);
if (originalDataset.InspireDeliveryMetadata != null)
{
originalDataset.InspireDeliveryMetadata.StatusId =
d.GetMetadataStatus(inspireDatasetFromKartkatalogen.Uuid, originalDataset.InspireDeliveryMetadata.AutoUpdate,
originalDataset.InspireDeliveryMetadata.StatusId);
}
originalDataset.InspireDeliveryMetadataService.StatusId = "good";
if (originalDataset.InspireDeliveryDistribution != null)
{
originalDataset.InspireDeliveryDistribution.StatusId =
d.GetDeliveryDistributionStatus(inspireDatasetFromKartkatalogen.Uuid, inspireDatasetFromKartkatalogen.DistributionUrl, originalDataset.InspireDeliveryDistribution.AutoUpdate,
originalDataset.InspireDeliveryDistribution.StatusId);
}
if (originalDataset.InspireDeliveryWms != null)
{
originalDataset.InspireDeliveryWms.StatusId = d.GetInspireWmsStatus(
inspireDatasetFromKartkatalogen.Uuid, originalDataset.InspireDeliveryWms.AutoUpdate, originalDataset.InspireDeliveryWms.StatusId,
originalDataset.UuidService);
}
if (originalDataset.InspireDeliveryWfs != null)
{
originalDataset.InspireDeliveryWfs.StatusId = d.GetInspireWfsStatus(inspireDatasetFromKartkatalogen.Uuid,
originalDataset.InspireDeliveryWfs.AutoUpdate, originalDataset.InspireDeliveryWfs.StatusId);
}
if (originalDataset.InspireDeliveryAtomFeed != null)
{
originalDataset.InspireDeliveryAtomFeed.StatusId =
d.GetAtomFeedStatus(inspireDatasetFromKartkatalogen.Uuid, originalDataset.InspireDeliveryAtomFeed.AutoUpdate,
originalDataset.InspireDeliveryAtomFeed.StatusId);
}
if (originalDataset.InspireDeliveryWfsOrAtom != null)
{
if (originalDataset.InspireDeliveryWfs != null && originalDataset.InspireDeliveryAtomFeed != null)
{
originalDataset.InspireDeliveryWfsOrAtom.StatusId = d.GetDownloadRequirementsStatus(originalDataset.InspireDeliveryWfs.StatusId, originalDataset.InspireDeliveryAtomFeed.StatusId);
}
else
{
originalDataset.InspireDeliveryWfsOrAtom.StatusId = "notset";
}
}
if (originalDataset.InspireDeliveryHarmonizedData != null)
{
originalDataset.InspireDeliveryHarmonizedData.StatusId =
d.GetHarmonizedStatus(inspireDatasetFromKartkatalogen.Uuid, originalDataset.InspireDeliveryHarmonizedData.AutoUpdate,
originalDataset.InspireDeliveryHarmonizedData.StatusId);
}
if (originalDataset.InspireDeliverySpatialDataService != null)
{
originalDataset.InspireDeliverySpatialDataService.StatusId =
d.GetSpatialDataStatus(inspireDatasetFromKartkatalogen.Uuid, originalDataset.InspireDeliverySpatialDataService.AutoUpdate,
originalDataset.InspireDeliverySpatialDataService.StatusId);
}
_dbContext.Entry(originalDataset).State = EntityState.Modified;
_dbContext.SaveChanges();
return(originalDataset);
}
//[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));
}
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);
}
private GeodatalovDataset UpdateGeodatalovDataset(GeodatalovDataset originalDataset, GeodatalovDataset geodatalovDatasetFromKartkatalogen)
{
originalDataset.Name = geodatalovDatasetFromKartkatalogen.Name;
originalDataset.Seoname = RegisterUrls.MakeSeoFriendlyString(originalDataset.Name);
originalDataset.Description = geodatalovDatasetFromKartkatalogen.Description;
originalDataset.OwnerId = geodatalovDatasetFromKartkatalogen.OwnerId;
originalDataset.Modified = DateTime.Now;
originalDataset.Uuid = geodatalovDatasetFromKartkatalogen.Uuid;
originalDataset.Notes = geodatalovDatasetFromKartkatalogen.Notes;
originalDataset.SpecificUsage = geodatalovDatasetFromKartkatalogen.SpecificUsage;
originalDataset.ProductSheetUrl = geodatalovDatasetFromKartkatalogen.ProductSheetUrl;
originalDataset.PresentationRulesUrl = geodatalovDatasetFromKartkatalogen.PresentationRulesUrl;
originalDataset.ProductSpecificationUrl = geodatalovDatasetFromKartkatalogen.ProductSpecificationUrl;
originalDataset.MetadataUrl = geodatalovDatasetFromKartkatalogen.MetadataUrl;
originalDataset.DistributionFormat = geodatalovDatasetFromKartkatalogen.DistributionFormat;
originalDataset.DistributionUrl = geodatalovDatasetFromKartkatalogen.DistributionUrl;
originalDataset.DistributionArea = geodatalovDatasetFromKartkatalogen.DistributionArea;
originalDataset.WmsUrl = geodatalovDatasetFromKartkatalogen.WmsUrl;
originalDataset.ThemeGroupId = geodatalovDatasetFromKartkatalogen.ThemeGroupId;
originalDataset.DatasetThumbnail = geodatalovDatasetFromKartkatalogen.DatasetThumbnail;
originalDataset.UuidService = geodatalovDatasetFromKartkatalogen.UuidService;
originalDataset.InspireTheme = geodatalovDatasetFromKartkatalogen.InspireTheme;
originalDataset.Dok = geodatalovDatasetFromKartkatalogen.Dok;
originalDataset.NationalDataset = geodatalovDatasetFromKartkatalogen.NationalDataset;
originalDataset.Plan = geodatalovDatasetFromKartkatalogen.Plan;
originalDataset.Geodatalov = geodatalovDatasetFromKartkatalogen.Geodatalov;
if (originalDataset.MetadataStatus != null)
{
originalDataset.MetadataStatus.StatusId = _datasetDeliveryService.GetMetadataStatus(geodatalovDatasetFromKartkatalogen.Uuid, true, originalDataset.MetadataStatus.StatusId);
}
if (originalDataset.ProductSpesificationStatus != null)
{
originalDataset.ProductSpesificationStatus.StatusId = _registerService.GetDOKStatus(geodatalovDatasetFromKartkatalogen.ProductSpecificationUrl, true, originalDataset.ProductSpesificationStatus.StatusId);
}
if (originalDataset.SosiDataStatus != null)
{
originalDataset.SosiDataStatus.StatusId = _registerService.GetSosiRequirements(geodatalovDatasetFromKartkatalogen.Uuid, originalDataset.ProductSpecificationUrl, true, originalDataset.SosiDataStatus.StatusId);
}
if (originalDataset.GmlDataStatus != null)
{
originalDataset.GmlDataStatus.StatusId = _registerService.GetGmlRequirements(geodatalovDatasetFromKartkatalogen.Uuid, true, originalDataset.GmlDataStatus.StatusId);
}
if (originalDataset.WmsStatus != null)
{
originalDataset.WmsStatus.StatusId = _datasetDeliveryService.GetDokDeliveryServiceStatus(geodatalovDatasetFromKartkatalogen.Uuid, true, originalDataset.WmsStatus.StatusId, geodatalovDatasetFromKartkatalogen.UuidService);
}
if (originalDataset.WfsStatus != null)
{
originalDataset.WfsStatus.StatusId = _datasetDeliveryService.GetWfsStatus(geodatalovDatasetFromKartkatalogen.Uuid, true, originalDataset.WfsStatus.StatusId);
}
if (originalDataset.AtomFeedStatus != null)
{
originalDataset.AtomFeedStatus.StatusId = _datasetDeliveryService.GetAtomFeedStatus(geodatalovDatasetFromKartkatalogen.Uuid, true, originalDataset.AtomFeedStatus.StatusId);
}
if (originalDataset.CommonStatus != null)
{
originalDataset.CommonStatus.StatusId = _datasetDeliveryService.GetDownloadRequirementsStatus(originalDataset.WfsStatus?.StatusId, originalDataset.AtomFeedStatus?.StatusId);
}
_dbContext.Entry(originalDataset).State = EntityState.Modified;
_dbContext.SaveChanges();
return(originalDataset);
}
private string OrganizationSeoName(string name)
{
return(RegisterUrls.MakeSeoFriendlyString(name));
}
public Dataset UpdateDataset(Dataset inputDataset, Dataset originalDataset = null, CoverageDataset coverage = null)
{
Dataset dataset = originalDataset ?? new Dataset();
dataset.systemId = inputDataset.GetSystemId();
dataset.modified = dataset.GetDateModified();
dataset.dateSubmitted = dataset.GetDateSubmbitted();
dataset.register = inputDataset.register;
dataset.registerId = inputDataset.registerId;
dataset.DatasetType = dataset.GetDatasetType();
dataset.statusId = dataset.SetStatusId();
dataset.dokStatusId = inputDataset.GetDokStatus();
dataset.dokStatusDateAccepted = inputDataset.GetDokStatusDateAccepted();
dataset.Kandidatdato = inputDataset.Kandidatdato;
dataset.versionNumber = dataset.GetVersionNr();
dataset.versioningId = GetVersioningId(dataset);
dataset.datasetownerId = GetDatasetOwnerId(inputDataset.datasetownerId);
dataset.datasetowner = (Organization)_registerItemService.GetRegisterItemBySystemId(dataset.datasetownerId);
dataset.submitterId = GetSubmitterId(inputDataset.submitterId);
dataset.submitter = (Organization)_registerItemService.GetRegisterItemBySystemId(dataset.submitterId);
dataset.Notes = inputDataset.GetNotes();
dataset.name = inputDataset.GetName();
dataset.seoname = RegisterUrls.MakeSeoFriendlyString(dataset.name);
dataset.description = inputDataset.GetDescription();
dataset.DistributionUrl = inputDataset.GetDistributionUrl();
dataset.MetadataUrl = inputDataset.GetMetadataUrl();
dataset.PresentationRulesUrl = inputDataset.GetPresentationRulesUrl();
dataset.ProductSheetUrl = inputDataset.GetProductSheetUrl();
dataset.ProductSpecificationUrl = inputDataset.GetProductSpecificationUrl();
dataset.UuidService = inputDataset.GetServceUuid();
dataset.WmsUrl = inputDataset.GetWmsUrl();
dataset.DistributionFormat = inputDataset.GetDistributionFormat();
dataset.DistributionArea = inputDataset.GetDistributionArea();
dataset.ThemeGroupId = inputDataset.GetThemeGroupId();
dataset.datasetthumbnail = inputDataset.Getdatasetthumbnail();
dataset.Uuid = inputDataset.Uuid;
dataset.SpecificUsage = inputDataset.SpecificUsage;
dataset.restricted = inputDataset.restricted;
dataset.dokDeliveryMetadataStatusId = _datasetDeliveryService.GetMetadataStatus(inputDataset.Uuid, inputDataset.dokDeliveryMetadataStatusAutoUpdate, inputDataset.dokDeliveryMetadataStatusId);
dataset.dokDeliveryMetadataStatusNote = inputDataset.dokDeliveryMetadataStatusNote;
dataset.dokDeliveryMetadataStatusAutoUpdate = inputDataset.dokDeliveryMetadataStatusAutoUpdate;
dataset.dokDeliveryProductSheetStatusId = _registerService.GetDOKStatus(inputDataset.GetProductSheetUrl(), inputDataset.dokDeliveryProductSheetStatusAutoUpdate, inputDataset.dokDeliveryProductSheetStatusId);
dataset.dokDeliveryProductSheetStatusNote = inputDataset.dokDeliveryProductSheetStatusNote;
dataset.dokDeliveryProductSheetStatusAutoUpdate = inputDataset.dokDeliveryProductSheetStatusAutoUpdate;
dataset.dokDeliveryPresentationRulesStatusId = _registerService.GetDOKStatus(inputDataset.GetPresentationRulesUrl(), inputDataset.dokDeliveryPresentationRulesStatusAutoUpdate, inputDataset.dokDeliveryPresentationRulesStatusId);
dataset.dokDeliveryPresentationRulesStatusNote = inputDataset.dokDeliveryPresentationRulesStatusNote;
dataset.dokDeliveryPresentationRulesStatusAutoUpdate = inputDataset.dokDeliveryPresentationRulesStatusAutoUpdate;
dataset.dokDeliveryProductSpecificationStatusId = _registerService.GetDOKStatus(inputDataset.GetProductSpecificationUrl(), inputDataset.dokDeliveryProductSpecificationStatusAutoUpdate, inputDataset.dokDeliveryProductSpecificationStatusId);
dataset.dokDeliveryProductSpecificationStatusNote = inputDataset.dokDeliveryProductSpecificationStatusNote;
dataset.dokDeliveryProductSpecificationStatusAutoUpdate = inputDataset.dokDeliveryProductSpecificationStatusAutoUpdate;
dataset.dokDeliveryWmsStatusId = _datasetDeliveryService.GetDokDeliveryServiceStatus(inputDataset.Uuid, inputDataset.dokDeliveryWmsStatusAutoUpdate, inputDataset.dokDeliveryWmsStatusId, inputDataset.UuidService);
dataset.dokDeliveryWmsStatusNote = inputDataset.dokDeliveryWmsStatusNote;
dataset.dokDeliveryWmsStatusAutoUpdate = inputDataset.dokDeliveryWmsStatusAutoUpdate;
dataset.dokDeliveryWfsStatusId = _datasetDeliveryService.GetWfsStatus(inputDataset.Uuid, inputDataset.dokDeliveryWfsStatusAutoUpdate, inputDataset.dokDeliveryWfsStatusId);
dataset.dokDeliveryWfsStatusNote = inputDataset.dokDeliveryWfsStatusNote;
dataset.dokDeliveryWfsStatusAutoUpdate = inputDataset.dokDeliveryWfsStatusAutoUpdate;
dataset.dokDeliverySosiRequirementsStatusId = _registerService.GetSosiRequirements(inputDataset.Uuid, inputDataset.GetProductSpecificationUrl(), inputDataset.dokDeliverySosiStatusAutoUpdate, inputDataset.dokDeliverySosiRequirementsStatusId);
dataset.dokDeliverySosiRequirementsStatusNote = inputDataset.dokDeliverySosiRequirementsStatusNote;
dataset.dokDeliverySosiStatusAutoUpdate = inputDataset.dokDeliverySosiStatusAutoUpdate;
dataset.dokDeliveryGmlRequirementsStatusId = _registerService.GetGmlRequirements(inputDataset.Uuid, inputDataset.dokDeliveryGmlRequirementsStatusAutoUpdate, inputDataset.dokDeliveryGmlRequirementsStatusId);
dataset.dokDeliveryGmlRequirementsStatusNote = inputDataset.dokDeliveryGmlRequirementsStatusNote;
dataset.dokDeliveryGmlRequirementsStatusAutoUpdate = inputDataset.dokDeliveryGmlRequirementsStatusAutoUpdate;
dataset.dokDeliveryAtomFeedStatusId = _datasetDeliveryService.GetAtomFeedStatus(inputDataset.Uuid, inputDataset.dokDeliveryAtomFeedStatusAutoUpdate, inputDataset.dokDeliveryAtomFeedStatusId);
dataset.dokDeliveryAtomFeedStatusNote = inputDataset.dokDeliveryAtomFeedStatusNote;
dataset.dokDeliveryAtomFeedStatusAutoUpdate = inputDataset.dokDeliveryAtomFeedStatusAutoUpdate;
dataset.dokDeliveryDistributionStatusNote = inputDataset.dokDeliveryDistributionStatusNote;
dataset.dokDeliveryDistributionStatusAutoUpdate = inputDataset.dokDeliveryDistributionStatusAutoUpdate;
dataset.dokDeliveryDistributionStatusId = inputDataset.dokDeliveryDistributionStatusId;
dataset.dokDeliveryDistributionStatusId = _registerService.GetDeliveryDownloadStatus(inputDataset.Uuid, inputDataset.dokDeliveryDistributionStatusAutoUpdate, dataset.dokDeliveryDistributionStatusId, dataset.dokDeliveryWfsStatusId, dataset.dokDeliveryAtomFeedStatusId);
dataset.Coverage = EditDatasetCoverage(coverage, dataset, originalDataset);
dataset.RegionalPlan = inputDataset.RegionalPlan;
dataset.RegionalPlanNote = inputDataset.RegionalPlanNote;
dataset.MunicipalSocialPlan = inputDataset.MunicipalSocialPlan;
dataset.MunicipalSocialPlanNote = inputDataset.MunicipalSocialPlanNote;
dataset.MunicipalLandUseElementPlan = inputDataset.MunicipalLandUseElementPlan;
dataset.MunicipalLandUseElementPlanNote = inputDataset.MunicipalLandUseElementPlanNote;
dataset.ZoningPlanArea = inputDataset.ZoningPlanArea;
dataset.ZoningPlanAreaNote = inputDataset.ZoningPlanAreaNote;
dataset.ZoningPlanDetails = inputDataset.ZoningPlanDetails;
dataset.ZoningPlanDetailsNote = inputDataset.ZoningPlanDetailsNote;
dataset.BuildingMatter = inputDataset.BuildingMatter;
dataset.BuildingMatterNote = inputDataset.BuildingMatterNote;
dataset.PartitionOff = inputDataset.PartitionOff;
dataset.PartitionOffNote = inputDataset.PartitionOffNote;
dataset.EenvironmentalImpactAssessment = inputDataset.EenvironmentalImpactAssessment;
dataset.EenvironmentalImpactAssessmentNote = inputDataset.EenvironmentalImpactAssessmentNote;
return(dataset);
}
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());
}
}
