public static GFBIOPangaeaFormularObject GetGFBIOPangaeaFormularObject(long datasetId)
{
DatasetManager datasetManager = new DatasetManager();
try
{
Dataset dataset = datasetManager.GetDataset(datasetId);
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(dataset.MetadataStructure.Id);
GFBIOPangaeaFormularObject gfbioPangaeaFormularObject = new GFBIOPangaeaFormularObject();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
string title = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.title);
string description = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.description);
return(gfbioPangaeaFormularObject);
}
finally
{
datasetManager.Dispose();
}
}
public static GFBIODataCenterFormularObject GetGFBIODataCenterFormularObject(long datasetId)
{
DatasetManager datasetManager = new DatasetManager();
try
{
Dataset dataset = datasetManager.GetDataset(datasetId);
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
GFBIODataCenterFormularObject gfbioDataCenterFormularObject = new GFBIODataCenterFormularObject();
//gfbioDataCenterFormularObject.ProjectId = 1;
//gfbioDataCenterFormularObject.ProjectTitle = "Test Poject title";
//gfbioDataCenterFormularObject.ProjectLabel = "Test Poject label";
//gfbioDataCenterFormularObject.ProjectAbstract = "";
//gfbioDataCenterFormularObject.ProjectPi = "ProjectPi";
//gfbioDataCenterFormularObject.UserId = 1;
//gfbioDataCenterFormularObject.UserName = "******";
//gfbioDataCenterFormularObject.UserEmail = "testEmail";
//gfbioDataCenterFormularObject.DatasetAuthor = "TestAuthor";
gfbioDataCenterFormularObject.DatasetId = datasetId;
gfbioDataCenterFormularObject.DatasetVersion = datasetVersion.Id;
gfbioDataCenterFormularObject.License = "";
gfbioDataCenterFormularObject.DatasetTitle = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.title);
gfbioDataCenterFormularObject.DatasetLabel = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.title);
gfbioDataCenterFormularObject.DatasetDescription = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.description);
//gfbioDataCenterFormularObject.DatasetAuthors = new List<string>();
gfbioDataCenterFormularObject.DatasetCollectionTime = datasetVersion.Dataset.LastCheckIOTimestamp;
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(dataset.MetadataStructure.Id);
gfbioDataCenterFormularObject.MetadataSchemaName = metadataStructure.Name;
return(gfbioDataCenterFormularObject);
}
finally
{
datasetManager.Dispose();
}
}
public StructuredDataStructure GetDataStructureByID(long ID)
{
DataStructureManager dsm = new DataStructureManager();
StructuredDataStructure structuredDataStructure = dsm.StructuredDataStructureRepo.Get(ID);
this.dataStructure = structuredDataStructure;
if (this.dataStructure != null)
{
this.variables = getOrderedVariables(structuredDataStructure);
if (this.dataStructure.Datasets == null)
{
inUse = false;
}
else
{
if (this.dataStructure.Datasets.Count > 0)
{
inUse = true;
DatasetListElement datasetListElement = new DatasetListElement();
DatasetManager dm = new DatasetManager();
foreach (Dataset d in structuredDataStructure.Datasets)
{
if (dm.GetDatasetLatestMetadataVersion(d.Id) != null)
{
datasetListElement = new DatasetListElement(d.Id, XmlDatasetHelper.GetInformation(d, AttributeNames.title));
}
else
{
datasetListElement = new DatasetListElement(0, "");
}
datasets.Add(datasetListElement);
}
}
else
{
inUse = false;
}
}
this.BuildDataTable();
return(structuredDataStructure);
}
else
{
this.dataStructure = new StructuredDataStructure();
return(structuredDataStructure);
}
}
public List <ListViewItem> LoadDatasetViewList()
{
List <ListViewItem> temp = new List <ListViewItem>();
DatasetManager datasetManager = new DatasetManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
//get all datasetsid where the current userer has access to
UserManager userManager = new UserManager();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
try
{
List <long> datasetIds = entityPermissionManager.GetKeys(GetUsernameOrDefault(), "Dataset",
typeof(Dataset), RightType.Write);
foreach (long id in datasetIds)
{
if (datasetManager.IsDatasetCheckedIn(id))
{
string title = xmlDatasetHelper.GetInformation(id, NameAttributeValues.title);
string description = xmlDatasetHelper.GetInformation(id, NameAttributeValues.description);
temp.Add(new ListViewItem(id, title, description));
}
}
return(temp.OrderBy(p => p.Title).ToList());
}
finally
{
datasetManager.Dispose();
entityPermissionManager.Dispose();
userManager.Dispose();
}
}
/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="ID"></param>
/// <param name="structured"></param>
/// <returns></returns>
public DataStructure GetDataStructureByID(long ID, bool structured)
{
this.structured = structured;
if (structured)
{
return(this.GetDataStructureByID(ID));
}
else
{
DataStructureManager dsm = new DataStructureManager();
UnStructuredDataStructure unStructuredDataStructure = dsm.UnStructuredDataStructureRepo.Get(ID);
this.dataStructure = unStructuredDataStructure;
if (this.dataStructure != null)
{
this.variables = null;
if (this.dataStructure.Datasets == null)
{
inUse = false;
}
else
{
if (this.dataStructure.Datasets.Count > 0)
{
inUse = true;
DatasetListElement datasetListElement = new DatasetListElement();
DatasetManager dm = new DatasetManager();
foreach (Dataset d in unStructuredDataStructure.Datasets)
{
datasetListElement = new DatasetListElement(d.Id, XmlDatasetHelper.GetInformation(d, AttributeNames.title));
datasets.Add(datasetListElement);
}
}
else
{
inUse = false;
}
}
return(unStructuredDataStructure);
}
else
{
this.dataStructure = new StructuredDataStructure();
return(unStructuredDataStructure);
}
}
}
public string GetTitleById(long id)
{
using (var uow = this.GetUnitOfWork())
{
var dm = new DatasetManager();
try
{
var datasetHelper = new XmlDatasetHelper();
return(datasetHelper.GetInformation(id, NameAttributeValues.title));
}
finally
{
dm.Dispose();
}
}
}
public void fillDatasetList()
{
DatasetListElement datasetListElement = new DatasetListElement();
DatasetManager dm = null;
datasets = new List <DatasetListElement>();
try
{
dm = new DatasetManager();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
foreach (var item in dm.GetDatasetLatestVersions(dataStructure.Id, true))
{
datasetListElement = new DatasetListElement(item.Key, xmlDatasetHelper.GetInformation(item.Value.Id, NameAttributeValues.title));
datasets.Add(datasetListElement);
}
}
finally
{
dm.Dispose();
}
}
//temporary solution: norman :FinishUpload2
public List <Error> FinishUpload(TaskManager taskManager)
{
DataStructureManager dsm = new DataStructureManager();
DatasetManager dm = new DatasetManager();
try
{
List <Error> temp = new List <Error>();
DatasetVersion workingCopy = new DatasetVersion();
//datatuple list
List <DataTuple> rows = new List <DataTuple>();
Dataset ds = null;
bool inputWasAltered = false;
if (TaskManager.Bus.ContainsKey(TaskManager.DATASET_ID) && TaskManager.Bus.ContainsKey(TaskManager.DATASTRUCTURE_ID))
{
long id = Convert.ToInt32(TaskManager.Bus[TaskManager.DATASET_ID]);
long iddsd = Convert.ToInt32(TaskManager.Bus[TaskManager.DATASTRUCTURE_ID]);
ds = dm.GetDataset(id);
// Javad: Please check if the dataset does exists!!
//GetValues from the previus version
// Status
DatasetVersion latestVersion = dm.GetDatasetLatestVersion(ds);
string status = DatasetStateInfo.NotValid.ToString();
if (latestVersion.StateInfo != null)
{
status = latestVersion.StateInfo.State;
}
#region Progress Informations
if (TaskManager.Bus.ContainsKey(TaskManager.CURRENTPACKAGESIZE))
{
TaskManager.Bus[TaskManager.CURRENTPACKAGESIZE] = 0;
}
else
{
TaskManager.Bus.Add(TaskManager.CURRENTPACKAGESIZE, 0);
}
if (TaskManager.Bus.ContainsKey(TaskManager.CURRENTPACKAGE))
{
TaskManager.Bus[TaskManager.CURRENTPACKAGE] = 0;
}
else
{
TaskManager.Bus.Add(TaskManager.CURRENTPACKAGE, 0);
}
#endregion
#region structured data
if (TaskManager.Bus.ContainsKey(TaskManager.DATASTRUCTURE_TYPE) && TaskManager.Bus[TaskManager.DATASTRUCTURE_TYPE].Equals(DataStructureType.Structured))
{
string title = "";
long datasetid = ds.Id;
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
title = xmlDatasetHelper.GetInformation(ds.Id, NameAttributeValues.title);
try
{
//Stopwatch fullTime = Stopwatch.StartNew();
//Stopwatch loadDT = Stopwatch.StartNew();
List <long> datatupleFromDatabaseIds = dm.GetDatasetVersionEffectiveTupleIds(dm.GetDatasetLatestVersion(ds.Id));
//loadDT.Stop();
//Debug.WriteLine("Load DT From Db Time " + loadDT.Elapsed.TotalSeconds.ToString());
StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(iddsd);
dsm.StructuredDataStructureRepo.LoadIfNot(sds.Variables);
#region excel reader
if (TaskManager.Bus[TaskManager.EXTENTION].ToString().Equals(".xlsm"))
{
int packageSize = 10000;
TaskManager.Bus[TaskManager.CURRENTPACKAGESIZE] = packageSize;
int counter = 0;
ExcelReader reader = new ExcelReader();
//schleife
dm.CheckOutDatasetIfNot(ds.Id, GetUsernameOrDefault()); // there are cases, the dataset does not get checked out!!
if (!dm.IsDatasetCheckedOutFor(ds.Id, GetUsernameOrDefault()))
{
throw new Exception(string.Format("Not able to checkout dataset '{0}' for user '{1}'!", ds.Id, GetUsernameOrDefault()));
}
workingCopy = dm.GetDatasetWorkingCopy(ds.Id);
//set StateInfo of the previus version
if (workingCopy.StateInfo == null)
{
workingCopy.StateInfo = new Vaiona.Entities.Common.EntityStateInfo()
{
State = status
};
}
else
{
workingCopy.StateInfo.State = status;
}
do
{
//Stopwatch packageTime = Stopwatch.StartNew();
counter++;
TaskManager.Bus[TaskManager.CURRENTPACKAGE] = counter;
// open file
Stream = reader.Open(TaskManager.Bus[TaskManager.FILEPATH].ToString());
Stopwatch upload = Stopwatch.StartNew();
rows = reader.ReadFile(Stream, TaskManager.Bus[TaskManager.FILENAME].ToString(), sds, (int)id, packageSize);
upload.Stop();
Debug.WriteLine("ReadFile: " + counter + " Time " + upload.Elapsed.TotalSeconds.ToString());
if (reader.ErrorMessages.Count > 0)
{
//model.ErrorList = reader.errorMessages;
}
else
{
//XXX Add packagesize to excel read function
if (TaskManager.Bus.ContainsKey(TaskManager.DATASET_STATUS))
{
if (TaskManager.Bus[TaskManager.DATASET_STATUS].ToString().Equals("new"))
{
upload = Stopwatch.StartNew();
dm.EditDatasetVersion(workingCopy, rows, null, null);
upload.Stop();
Debug.WriteLine("EditDatasetVersion: " + counter + " Time " + upload.Elapsed.TotalSeconds.ToString());
//Debug.WriteLine("----");
}
if (TaskManager.Bus[TaskManager.DATASET_STATUS].ToString().Equals("edit"))
{
if (rows.Count() > 0)
{
//Stopwatch split = Stopwatch.StartNew();
Dictionary <string, List <DataTuple> > splittedDatatuples = new Dictionary <string, List <DataTuple> >();
splittedDatatuples = uploadWizardHelper.GetSplitDatatuples(rows, (List <long>)TaskManager.Bus[TaskManager.PRIMARY_KEYS], workingCopy, ref datatupleFromDatabaseIds);
//split.Stop();
//Debug.WriteLine("Split : " + counter + " Time " + split.Elapsed.TotalSeconds.ToString());
//Stopwatch upload = Stopwatch.StartNew();
dm.EditDatasetVersion(workingCopy, splittedDatatuples["new"], splittedDatatuples["edit"], null);
// upload.Stop();
// Debug.WriteLine("Upload : " + counter + " Time " + upload.Elapsed.TotalSeconds.ToString());
// Debug.WriteLine("----");
}
}
}
else
{
}
}
Stream.Close();
//packageTime.Stop();
//Debug.WriteLine("Package : " + counter + " packageTime Time " + packageTime.Elapsed.TotalSeconds.ToString());
} while (rows.Count() > 0);
//fullTime.Stop();
//Debug.WriteLine("FullTime " + fullTime.Elapsed.TotalSeconds.ToString());
}
#endregion
#region ascii reader
if (TaskManager.Bus[TaskManager.EXTENTION].ToString().Equals(".csv") ||
TaskManager.Bus[TaskManager.EXTENTION].ToString().Equals(".txt"))
{
// open file
AsciiReader reader = new AsciiReader();
//Stream = reader.Open(TaskManager.Bus[TaskManager.FILEPATH].ToString());
//DatasetManager dm = new DatasetManager();
//Dataset ds = dm.GetDataset(id);
Stopwatch totalTime = Stopwatch.StartNew();
if (dm.IsDatasetCheckedOutFor(ds.Id, GetUsernameOrDefault()) || dm.CheckOutDataset(ds.Id, GetUsernameOrDefault()))
{
workingCopy = dm.GetDatasetWorkingCopy(ds.Id);
int packageSize = 100000;
TaskManager.Bus[TaskManager.CURRENTPACKAGESIZE] = packageSize;
//schleife
int counter = 0;
//set StateInfo of the previus version
if (workingCopy.StateInfo == null)
{
workingCopy.StateInfo = new Vaiona.Entities.Common.EntityStateInfo()
{
State = status
};
}
else
{
workingCopy.StateInfo.State = status;
}
do
{
counter++;
inputWasAltered = false;
TaskManager.Bus[TaskManager.CURRENTPACKAGE] = counter;
Stream = reader.Open(TaskManager.Bus[TaskManager.FILEPATH].ToString());
rows = reader.ReadFile(Stream, TaskManager.Bus[TaskManager.FILENAME].ToString(), (AsciiFileReaderInfo)TaskManager.Bus[TaskManager.FILE_READER_INFO], sds, id, packageSize);
Stream.Close();
if (reader.ErrorMessages.Count > 0)
{
foreach (var err in reader.ErrorMessages)
{
temp.Add(new Error(ErrorType.Dataset, err.GetMessage()));
}
//return temp;
}
//model.Validated = true;
Stopwatch dbTimer = Stopwatch.StartNew();
if (TaskManager.Bus.ContainsKey(TaskManager.DATASET_STATUS))
{
if (TaskManager.Bus[TaskManager.DATASET_STATUS].ToString().Equals("new"))
{
dm.EditDatasetVersion(workingCopy, rows, null, null);
}
if (TaskManager.Bus[TaskManager.DATASET_STATUS].ToString().Equals("edit"))
{
if (rows.Count() > 0)
{
//Dictionary<string, List<DataTuple>> splittedDatatuples = new Dictionary<string, List<AbstractTuple>>();
var splittedDatatuples = uploadWizardHelper.GetSplitDatatuples(rows, (List <long>)TaskManager.Bus[TaskManager.PRIMARY_KEYS], workingCopy, ref datatupleFromDatabaseIds);
dm.EditDatasetVersion(workingCopy, splittedDatatuples["new"], splittedDatatuples["edit"], null);
inputWasAltered = true;
}
}
}
else
{
if (rows.Count() > 0)
{
Dictionary <string, List <DataTuple> > splittedDatatuples = new Dictionary <string, List <DataTuple> >();
splittedDatatuples = uploadWizardHelper.GetSplitDatatuples(rows, (List <long>)TaskManager.Bus[TaskManager.PRIMARY_KEYS], workingCopy, ref datatupleFromDatabaseIds);
dm.EditDatasetVersion(workingCopy, splittedDatatuples["new"], splittedDatatuples["edit"], null);
inputWasAltered = true;
}
}
dbTimer.Stop();
Debug.WriteLine(" db time" + dbTimer.Elapsed.TotalSeconds.ToString());
} while (rows.Count() > 0 || inputWasAltered == true);
totalTime.Stop();
Debug.WriteLine(" Total Time " + totalTime.Elapsed.TotalSeconds.ToString());
}
//Stream.Close();
}
#endregion
#region contentdescriptors
//remove all contentdescriptors from the old version
//generatedTXT
if (workingCopy.ContentDescriptors.Any(c => c.Name.Equals("generatedTXT")))
{
ContentDescriptor tmp =
workingCopy.ContentDescriptors.Where(c => c.Name.Equals("generatedTXT"))
.FirstOrDefault();
dm.DeleteContentDescriptor(tmp);
}
//generatedCSV
if (workingCopy.ContentDescriptors.Any(c => c.Name.Equals("generatedCSV")))
{
ContentDescriptor tmp =
workingCopy.ContentDescriptors.Where(c => c.Name.Equals("generatedCSV"))
.FirstOrDefault();
dm.DeleteContentDescriptor(tmp);
}
//generated
if (workingCopy.ContentDescriptors.Any(c => c.Name.Equals("generated")))
{
ContentDescriptor tmp =
workingCopy.ContentDescriptors.Where(c => c.Name.Equals("generated"))
.FirstOrDefault();
dm.DeleteContentDescriptor(tmp);
}
#endregion
// ToDo: Get Comment from ui and users
MoveAndSaveOriginalFileInContentDiscriptor(workingCopy);
dm.CheckInDataset(ds.Id, "upload data from upload wizard", GetUsernameOrDefault());
//send email
var es = new EmailService();
es.Send(MessageHelper.GetUpdateDatasetHeader(),
MessageHelper.GetUpdateDatasetMessage(datasetid, title, GetUsernameOrDefault()),
ConfigurationManager.AppSettings["SystemEmail"]
);
}
catch (Exception e)
{
temp.Add(new Error(ErrorType.Other, "Can not upload. : " + e.Message));
var es = new EmailService();
es.Send(MessageHelper.GetErrorHeader(),
"Can not upload. : " + e.Message,
ConfigurationManager.AppSettings["SystemEmail"]
);
}
finally
{
}
}
#endregion
#region unstructured data
if (TaskManager.Bus.ContainsKey(TaskManager.DATASTRUCTURE_TYPE) && TaskManager.Bus[TaskManager.DATASTRUCTURE_TYPE].Equals(DataStructureType.Unstructured))
{
// checkout the dataset, apply the changes, and check it in.
if (dm.IsDatasetCheckedOutFor(ds.Id, GetUsernameOrDefault()) || dm.CheckOutDataset(ds.Id, GetUsernameOrDefault()))
{
try
{
workingCopy = dm.GetDatasetWorkingCopy(ds.Id);
using (var unitOfWork = this.GetUnitOfWork())
{
workingCopy = unitOfWork.GetReadOnlyRepository <DatasetVersion>().Get(workingCopy.Id);
//set StateInfo of the previus version
if (workingCopy.StateInfo == null)
{
workingCopy.StateInfo = new Vaiona.Entities.Common.EntityStateInfo()
{
State = status
};
}
else
{
workingCopy.StateInfo.State = status;
}
unitOfWork.GetReadOnlyRepository <DatasetVersion>().Load(workingCopy.ContentDescriptors);
SaveFileInContentDiscriptor(workingCopy);
}
dm.EditDatasetVersion(workingCopy, null, null, null);
// ToDo: Get Comment from ui and users
dm.CheckInDataset(ds.Id, "upload unstructured data", GetUsernameOrDefault(), ViewCreationBehavior.None);
}
catch (Exception ex)
{
throw ex;
}
}
}
#endregion
}
else
{
temp.Add(new Error(ErrorType.Dataset, "Dataset is not selected."));
}
if (temp.Count <= 0)
{
dm.CheckInDataset(ds.Id, "checked in but no update on data tuples", GetUsernameOrDefault(), ViewCreationBehavior.None);
}
else
{
dm.UndoCheckoutDataset(ds.Id, GetUsernameOrDefault());
}
return(temp);
}
finally
{
dm.Dispose();
dsm.Dispose();
}
}
//ToDO -> David <- do not store the files on the server
public string Convert(long datasetVersionId)
{
string datarepo = _dataRepo.Name;
DatasetManager datasetManager = new DatasetManager();
DataStructureManager dataStructureManager = new DataStructureManager();
PublicationManager publicationManager = new PublicationManager();
SubmissionManager publishingManager = new SubmissionManager();
try
{
DatasetVersion datasetVersion = datasetManager.GetDatasetVersion(datasetVersionId);
long datasetId = datasetVersion.Dataset.Id;
Publication publication =
publicationManager.GetPublication()
.Where(
p =>
p.DatasetVersion.Id.Equals(datasetVersion.Id) &&
p.Broker.Name.ToLower().Equals(_broker.Name))
.FirstOrDefault();
// if(broker exist)
if (publication == null && _broker != null)
{
Broker broker = _broker;
if (broker != null)
{
OutputMetadataManager.GetConvertedMetadata(datasetId, TransmissionType.mappingFileExport,
broker.MetadataFormat);
// get primary data
// check the data sturcture type ...
if (datasetVersion.Dataset.DataStructure.Self is StructuredDataStructure)
{
OutputDataManager odm = new OutputDataManager();
// apply selection and projection
string title = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.title);
odm.GenerateAsciiFile(datasetId, title, broker.PrimaryDataFormat);
}
string zipName = publishingManager.GetZipFileName(datasetId, datasetVersion.Id);
string zipPath = publishingManager.GetDirectoryPath(datasetId, broker.Name);
string dynamicZipPath = publishingManager.GetDynamicDirectoryPath(datasetId, broker.Name);
string zipFilePath = Path.Combine(zipPath, zipName);
string dynamicFilePath = Path.Combine(dynamicZipPath, zipName);
FileHelper.CreateDicrectoriesIfNotExist(Path.GetDirectoryName(zipFilePath));
if (FileHelper.FileExist(zipFilePath))
{
if (FileHelper.WaitForFile(zipFilePath))
{
FileHelper.Delete(zipFilePath);
}
}
// add datastructure
//ToDo put that functiom to the outputDatatructureManager
#region datatructure
long dataStructureId = datasetVersion.Dataset.DataStructure.Id;
DataStructure dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId);
if (dataStructure != null)
{
try
{
string dynamicPathOfDS = "";
dynamicPathOfDS = storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion,
"datastructure", ".txt");
string datastructureFilePath = AsciiWriter.CreateFile(dynamicPathOfDS);
string json = OutputDataStructureManager.GetVariableListAsJson(datasetId);
AsciiWriter.AllTextToFile(datastructureFilePath, json);
}
catch (Exception ex)
{
throw ex;
}
}
#endregion
ZipFile zip = new ZipFile();
foreach (ContentDescriptor cd in datasetVersion.ContentDescriptors)
{
string path = Path.Combine(AppConfiguration.DataPath, cd.URI);
string name = cd.URI.Split('\\').Last();
if (FileHelper.FileExist(path))
{
zip.AddFile(path, "");
}
}
// add xsd of the metadata schema
string xsdDirectoryPath = OutputMetadataManager.GetSchemaDirectoryPath(datasetId);
if (Directory.Exists(xsdDirectoryPath))
{
zip.AddDirectory(xsdDirectoryPath, "Schema");
}
XmlDocument manifest = OutputDatasetManager.GenerateManifest(datasetId, datasetVersion.Id);
if (manifest != null)
{
string dynamicManifestFilePath = OutputDatasetManager.GetDynamicDatasetStorePath(datasetId,
datasetVersion.Id, "manifest", ".xml");
string fullFilePath = Path.Combine(AppConfiguration.DataPath, dynamicManifestFilePath);
manifest.Save(fullFilePath);
zip.AddFile(fullFilePath, "");
}
string message = string.Format("dataset {0} version {1} was published for repository {2}", datasetId,
datasetVersion.Id, broker.Name);
LoggerFactory.LogCustom(message);
//Session["ZipFilePath"] = dynamicFilePath;
zip.Save(zipFilePath);
return(zipFilePath);
}
}
return("");
}
finally
{
datasetManager.Dispose();
dataStructureManager.Dispose();
publicationManager.Dispose();
}
}
public async Task <HttpResponseMessage> Put(int id)
{
var request = Request.CreateResponse();
User user = null;
string error = "";
DatasetManager datasetManager = new DatasetManager();
UserManager userManager = new UserManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
try
{
#region security
string token = this.Request.Headers.Authorization?.Parameter;
if (String.IsNullOrEmpty(token))
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "Bearer token not exist."));
}
user = userManager.Users.Where(u => u.Token.Equals(token)).FirstOrDefault();
if (user == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Token is not valid."));
}
//check permissions
//entity permissions
if (id > 0)
{
Dataset d = datasetManager.GetDataset(id);
if (d == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "the dataset with the id (" + id + ") does not exist."));
}
if (!entityPermissionManager.HasEffectiveRight(user.Name, typeof(Dataset), id, RightType.Write))
{
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "The token is not authorized to write into the dataset."));
}
}
#endregion security
#region check incomming metadata
Stream requestStream = await this.Request.Content.ReadAsStreamAsync();
string contentType = this.Request.Content.Headers.ContentType.MediaType;
if (string.IsNullOrEmpty(contentType) || (!contentType.Equals("application/xml") && !contentType.Equals("text/plain")))
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "The transmitted file is not a xml document."));
}
if (requestStream == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "Metadata xml was not received."));
}
#endregion check incomming metadata
#region incomming values check
// check incomming values
if (id == 0)
{
error += "dataset id should be greater then 0.";
}
////if (data.UpdateMethod == null) error += "update method is not set";
////if (data.Count == 0) error += "count should be greater then 0. ";
//if (data.Columns == null) error += "cloumns should not be null. ";
//if (data.Data == null) error += "data is empty. ";
//if (data.PrimaryKeys == null || data.PrimaryKeys.Count() == 0) error += "the UpdateMethod update has been selected but there are no primary keys available. ";
if (!string.IsNullOrEmpty(error))
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, error));
}
#endregion incomming values check
Dataset dataset = datasetManager.GetDataset(id);
if (dataset == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, "Dataset not exist."));
}
#region convert metadata
XmlDocument metadataForImport = new XmlDocument();
metadataForImport.Load(requestStream);
// metadataStructure ID
var metadataStructureId = dataset.MetadataStructure.Id;
var metadataStructrueName = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId).Name;
// loadMapping file
var path_mappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), XmlMetadataImportHelper.GetMappingFileName(metadataStructureId, TransmissionType.mappingFileImport, metadataStructrueName));
// XML mapper + mapping file
var xmlMapperManager = new XmlMapperManager(TransactionDirection.ExternToIntern);
xmlMapperManager.Load(path_mappingFile, "IDIV");
// generate intern metadata without internal attributes
var metadataResult = xmlMapperManager.Generate(metadataForImport, 1, true);
// generate intern template metadata xml with needed attribtes
var xmlMetadatWriter = new XmlMetadataWriter(BExIS.Xml.Helpers.XmlNodeMode.xPath);
var metadataXml = xmlMetadatWriter.CreateMetadataXml(metadataStructureId,
XmlUtility.ToXDocument(metadataResult));
var metadataXmlTemplate = XmlMetadataWriter.ToXmlDocument(metadataXml);
// set attributes FROM metadataXmlTemplate TO metadataResult
var completeMetadata = XmlMetadataImportHelper.FillInXmlValues(metadataResult,
metadataXmlTemplate);
#endregion convert metadata
if (completeMetadata != null)
{
string title = "";
if (datasetManager.IsDatasetCheckedOutFor(id, user.Name) || datasetManager.CheckOutDataset(id, user.Name))
{
DatasetVersion workingCopy = datasetManager.GetDatasetWorkingCopy(id);
workingCopy.Metadata = completeMetadata;
workingCopy.Title = xmlDatasetHelper.GetInformation(id, completeMetadata, NameAttributeValues.title);
workingCopy.Description = xmlDatasetHelper.GetInformation(id, completeMetadata, NameAttributeValues.description);
//check if modul exist
int v = 1;
if (workingCopy.Dataset.Versions != null && workingCopy.Dataset.Versions.Count > 1)
{
v = workingCopy.Dataset.Versions.Count();
}
//set status
if (workingCopy.StateInfo == null)
{
workingCopy.StateInfo = new Vaiona.Entities.Common.EntityStateInfo();
}
workingCopy.StateInfo.State = DatasetStateInfo.NotValid.ToString();
title = workingCopy.Title;
if (string.IsNullOrEmpty(title))
{
title = "No Title available.";
}
datasetManager.EditDatasetVersion(workingCopy, null, null, null);
datasetManager.CheckInDataset(id, "via api.", user.Name, ViewCreationBehavior.None);
}
// ToDo add Index update to this api
//if (this.IsAccessible("DDM", "SearchIndex", "ReIndexSingle"))
//{
// var x = this.Run("DDM", "SearchIndex", "ReIndexSingle", new RouteValueDictionary() { { "id", datasetId } });
//}
LoggerFactory.LogData(id.ToString(), typeof(Dataset).Name, Vaiona.Entities.Logging.CrudState.Created);
var es = new EmailService();
es.Send(MessageHelper.GetUpdateDatasetHeader(id),
MessageHelper.GetUpdateDatasetMessage(id, title, user.DisplayName),
ConfigurationManager.AppSettings["SystemEmail"]
);
}
return(Request.CreateErrorResponse(HttpStatusCode.OK, "Metadata successfully updated "));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
finally
{
datasetManager.Dispose();
entityPermissionManager.Dispose();
userManager.Dispose();
request.Dispose();
}
}
public bool Save(EditModel model)
{
// validate incoming data
if (model == null)
{
throw new Exception("model is empty.");
}
if (model.Id <= 0)
{
throw new Exception("Id is missing.");
}
// get current datasettitle
string layerName = "";
using (var datasetManager = new DatasetManager())
{
var dataset = datasetManager.GetDataset(model.Id);
if (dataset == null)
{
throw new Exception("Dataset with id " + model.Id + "not exist.");
}
XmlDatasetHelper xmlHelpers = new XmlDatasetHelper();
layerName = xmlHelpers.GetInformation(dataset, NameAttributeValues.title);
TimeObject to = new TimeObject(80000, model.Time, new Format()
{
format = "custom", customFormat = model.TimeFormat
});
GeoEngine geoEngine = new GeoEngine(
model.Longitude,
model.Latitude,
model.DataType,
model.SpatialReference,
layerName,
GetTypeSortedVariables(dataset.DataStructure.Id),
GetVariablesWithType(dataset.DataStructure.Id),
to
);
string path = Path.Combine(AppConfiguration.DataPath, "Datasets", model.Id.ToString(), "geoengine.json");
// check if directory exist, if not create
if (!Directory.Exists(Path.GetDirectoryName(path)))
{
FileHelper.CreateDicrectoriesIfNotExist(Path.GetDirectoryName(path));
}
// if file exist -> delete
if (FileHelper.FileExist(path))
{
File.Delete(path);
}
// save json to file
File.WriteAllText(path, JsonConvert.SerializeObject(geoEngine));
return(true);
}
}
