public List <EntityStoreItem> GetVersionsById(long id)
{
DatasetManager dm = new DatasetManager();
List <EntityStoreItem> tmp = new List <EntityStoreItem>();
try
{
var datasetIds = dm.GetDatasetLatestIds();
var datasetHelper = new XmlDatasetHelper();
var versions = dm.GetDataset(id).Versions.OrderBy(v => v.Timestamp).ToList();
foreach (var v in versions)
{
tmp.Add(new EntityStoreItem()
{
Id = v.Id,
Title = datasetHelper.GetInformationFromVersion(v.Id, NameAttributeValues.title),
Version = versions.IndexOf(v) + 1,
CommitComment = "(" + v.Timestamp.ToString("dd.MM.yyyy HH:mm") + "): " + v.ChangeDescription
});
}
return(tmp);
}
catch (Exception ex)
{
return(tmp);
}
finally
{
dm.Dispose();
}
}
private void addSelectedDatasetToBus(long datasetId)
{
DatasetManager datasetManager = new DatasetManager();
try
{
TaskManager = (TaskManager)Session["TaskManager"];
if (datasetManager.GetDatasetVersionEffectiveTupleCount(datasetManager.GetDatasetLatestVersion(datasetId)) > 0)
{
TaskManager.AddToBus("DatasetStatus", "edit");
}
else
{
TaskManager.AddToBus("DatasetStatus", "new");
}
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
TaskManager.AddToBus(TaskManager.DATASET_ID, datasetId);
//Add Metadata to Bus
//TITLE
TaskManager.AddToBus(TaskManager.DATASET_TITLE, xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title));
ResearchPlanManager rpm = new ResearchPlanManager();
ResearchPlan rp = rpm.Repo.Get(datasetVersion.Dataset.ResearchPlan.Id);
TaskManager.AddToBus(TaskManager.RESEARCHPLAN_ID, rp.Id);
TaskManager.AddToBus(TaskManager.RESEARCHPLAN_TITLE, rp.Title);
}
finally
{
datasetManager.Dispose();
}
}
// GET: api/data/5
/// <summary>
/// In addition to the id, it is possible to have projection and selection criteria passed to the action via query string parameters
/// </summary>
/// <param name="id">Dataset Id</param>
/// <returns></returns>
/// <remarks> The action accepts the following additional parameters via the query string
/// 1: projection: is a comman separated list of ids that determines which variables of the dataset version tuples should take part in the result set
/// 2: selection: is a logical expression that filters the tuples of the chosen dataset. The expression should have been written against the variables of the dataset only.
/// logical operators, nesting, precedence, and SOME functions should be supported.
/// /api/data/6?header=TimeUTC,D8CO1_1&filter=TimeUTC<5706000
/// </remarks>
public HttpResponseMessage Get(int id)
{
string projection = this.Request.GetQueryNameValuePairs().FirstOrDefault(p => "header".Equals(p.Key, StringComparison.InvariantCultureIgnoreCase)).Value;
string selection = this.Request.GetQueryNameValuePairs().FirstOrDefault(p => "filter".Equals(p.Key, StringComparison.InvariantCultureIgnoreCase)).Value;
DatasetManager datasetManager = new DatasetManager();
try
{
OutputDataManager ioOutputDataManager = new OutputDataManager();
DatasetVersion version = datasetManager.GetDatasetLatestVersion(id);
string title = xmlDatasetHelper.GetInformationFromVersion(version.Id, NameAttributeValues.title);
// check the data sturcture type ...
if (version.Dataset.DataStructure.Self is StructuredDataStructure)
{
// apply selection and projection
//var tuples = dm.GetDatasetVersionEffectiveTuples(version);
DataTable dt = OutputDataManager.ConvertPrimaryDataToDatatable(datasetManager, version, title, true);
if (!string.IsNullOrEmpty(selection))
{
dt = OutputDataManager.SelectionOnDataTable(dt, selection);
}
if (!string.IsNullOrEmpty(projection))
{
// make the header names upper case to make them case insensitive
dt = OutputDataManager.ProjectionOnDataTable(dt, projection.ToUpper().Split(','));
}
DatasetModel model = new DatasetModel();
model.DataTable = dt;
var response = Request.CreateResponse();
response.Content = new ObjectContent(typeof(DatasetModel), model, new DatasetModelCsvFormatter(model.DataTable.TableName));
//set headers on the "response"
return(response);
//return model;
}
else
{
return(Request.CreateResponse());
}
}
finally
{
datasetManager.Dispose();
}
}
public static DatasetGridRowModel Convert(DatasetVersion datasetVersion, bool isPublic)
{
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
return(new DatasetGridRowModel()
{
Id = datasetVersion.Dataset.Id,
Title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title),
IsPublic = isPublic
});
}
public static string CreateConvertedMetadata(long datasetId, TransmissionType type)
{
XmlDocument newXml;
DatasetManager datasetManager = new DatasetManager();
MetadataStructureManager metadataMetadataStructureManager = new MetadataStructureManager();
try
{
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
MetadataStructure metadataStructure = metadataMetadataStructureManager.Repo.Get(datasetVersion.Dataset.MetadataStructure.Id);
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
string mappingName = metadataStructure.Name;
string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName);
string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName);
XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
xmlMapperManager.Load(pathMappingFile, "exporttest");
newXml = xmlMapperManager.Export(datasetVersion.Metadata, datasetVersion.Id, mappingName, true);
string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title);
// store in content descriptor
string filename = "metadata";
if (String.IsNullOrEmpty(mappingName) || mappingName.ToLower() == "generic")
{
storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, filename, ".xml");
}
else
{
filename = "metadata_" + mappingName;
storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, filename,
".xml");
}
return(OutputDatasetManager.GetDynamicDatasetStorePath(datasetId, datasetVersion.Id, filename, ".xml"));
}
catch (Exception ex)
{
throw ex;
}
finally
{
datasetManager.Dispose();
metadataMetadataStructureManager.Dispose();
}
return("");
}
public static XmlDocument GetConvertedMetadata(long datasetId, TransmissionType type, string mappingName, bool storing = true)
{
XmlDocument newXml;
DatasetManager datasetManager = new DatasetManager();
try
{
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName);
string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName);
XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
xmlMapperManager.Load(pathMappingFile, "exporttest");
newXml = xmlMapperManager.Export(datasetVersion.Metadata, datasetVersion.Id, mappingName, true);
string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title);
// store in content descriptor
if (storing)
{
if (String.IsNullOrEmpty(mappingName) || mappingName.ToLower() == "generic")
{
storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "metadata", ".xml");
}
else
{
storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "metadata_" + mappingName, ".xml");
}
}
}
catch (Exception ex)
{
throw ex;
}
return(newXml);
}
private List <DatasetVersionModel> getDatasetVersionsDic(MetadataStructure metadataStructure, List <long> datasetVersionIds)
{
List <DatasetVersionModel> datasetVersions = new List <DatasetVersionModel>();
DatasetManager datasetManager = new DatasetManager();
try
{
using (var uow = this.GetUnitOfWork())
{
// gets all the dataset versions that their Id is in the datasetVersionIds and they are using a specific metadata structure as indicated by metadataStructure parameter
var q = uow.GetReadOnlyRepository <DatasetVersion>().Get(p => datasetVersionIds.Contains(p.Id) &&
p.Dataset.MetadataStructure.Id.Equals(metadataStructure.Id)).Distinct();
foreach (DatasetVersion datasetVersion in q)
{
if (datasetManager.IsDatasetCheckedIn(datasetVersion.Dataset.Id))
{
uow.GetReadOnlyRepository <DatasetVersion>().Load(datasetVersion.ContentDescriptors);
datasetVersions.Add(
new DatasetVersionModel
{
DatasetVersionId = datasetVersion.Id,
DatasetId = datasetVersion.Dataset.Id,
Title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title),
MetadataDownloadPath = OutputMetadataManager.GetMetadataPath(datasetVersion.ContentDescriptors)
});
}
}
return(datasetVersions);
}
}
finally
{
datasetManager.Dispose();
}
}
/// <summary>
/// create a model to fill the table of My Dataset
/// </summary>
/// <remarks></remarks>
/// <seealso cref="ShowMyDatasets"/>
/// <param>NA</param>
/// <returns>model</returns>
public ActionResult _CustomMyDatasetBinding()
{
DataTable model = new DataTable();
ViewData["PageSize"] = 10;
ViewData["CurrentPage"] = 1;
#region header
List <HeaderItem> headerItems = CreateHeaderItems();
ViewData["DefaultHeaderList"] = headerItems;
#endregion
model = CreateDataTable(headerItems);
DatasetManager datasetManager = new DatasetManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
UserManager userManager = new UserManager();
EntityManager entityManager = new EntityManager();
try
{
var entity = entityManager.FindByName("Dataset");
var user = userManager.FindByNameAsync(GetUsernameOrDefault()).Result;
List <long> gridCommands = datasetManager.GetDatasetLatestIds();
gridCommands.Skip(Convert.ToInt16(ViewData["CurrentPage"])).Take(Convert.ToInt16(ViewData["PageSize"]));
foreach (long datasetId in gridCommands)
{
//get permissions
int rights = entityPermissionManager.GetEffectiveRights(user?.Id, entity.Id, datasetId);
if (rights > 0)
{
DataRow dataRow = model.NewRow();
Object[] rowArray = new Object[8];
if (datasetManager.IsDatasetCheckedIn(datasetId))
{
//long versionId = datasetManager.GetDatasetLatestVersionId (datasetId); // check for zero value
//DatasetVersion dsv = datasetManager.DatasetVersionRepo.Get(versionId);
DatasetVersion dsv = datasetManager.GetDatasetLatestVersion(datasetId);
//MetadataStructureManager msm = new MetadataStructureManager();
//dsv.Dataset.MetadataStructure = msm.Repo.Get(dsv.Dataset.MetadataStructure.Id);
string title = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.title);
string description = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.description);
rowArray[0] = Convert.ToInt64(datasetId);
rowArray[1] = title;
rowArray[2] = description;
}
else
{
rowArray[0] = Convert.ToInt64(datasetId);
rowArray[1] = "";
rowArray[2] = "Dataset is just in processing.";
}
rowArray[3] = (rights & (int)RightType.Read) > 0 ? "✔" : "✘";
rowArray[4] = (rights & (int)RightType.Write) > 0 ? "✔" : "✘";
rowArray[5] = (rights & (int)RightType.Delete) > 0 ? "✔" : "✘";
rowArray[6] = (rights & (int)RightType.Download) > 0 ? "✔" : "✘";
rowArray[7] = (rights & (int)RightType.Grant) > 0 ? "✔" : "✘";
dataRow = model.NewRow();
dataRow.ItemArray = rowArray;
model.Rows.Add(dataRow);
}
}
return(View(new GridModel(model)));
}
finally
{
datasetManager.Dispose();
entityPermissionManager.Dispose();
entityManager.Dispose();
userManager.Dispose();
}
}
public ActionResult ShowData(long id)
{
DatasetManager dm = new DatasetManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
try
{
DatasetVersion dsv;
ShowDataModel model = new ShowDataModel();
string title = "";
long metadataStructureId = -1;
long dataStructureId = -1;
long researchPlanId = 1;
XmlDocument metadata = new XmlDocument();
if (dm.IsDatasetCheckedIn(id))
{
long versionId = dm.GetDatasetLatestVersionId(id); // check for zero value
dsv = dm.DatasetVersionRepo.Get(versionId); // this is needed to allow dsv to access to an open session that is available via the repo
metadataStructureId = dsv.Dataset.MetadataStructure.Id;
//MetadataStructureManager msm = new MetadataStructureManager();
//dsv.Dataset.MetadataStructure = msm.Repo.Get(dsv.Dataset.MetadataStructure.Id);
title = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.title); // this function only needs metadata and extra fields, there is no need to pass the version to it.
dataStructureId = dsv.Dataset.DataStructure.Id;
researchPlanId = dsv.Dataset.ResearchPlan.Id;
metadata = dsv.Metadata;
ViewBag.Title = PresentationModel.GetViewTitleForTenant("Show Data : " + title, this.Session.GetTenant());
}
else
{
ModelState.AddModelError(string.Empty, "Dataset is just in processing.");
}
model = new ShowDataModel()
{
Id = id,
Title = title,
MetadataStructureId = metadataStructureId,
DataStructureId = dataStructureId,
ResearchPlanId = researchPlanId,
ViewAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, "Dataset", typeof(Dataset), id, RightType.Read),
GrantAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, "Dataset", typeof(Dataset), id, RightType.Grant)
};
//set metadata in session
Session["ShowDataMetadata"] = metadata;
return(View(model));
}
finally
{
dm.Dispose();
entityPermissionManager.Dispose();
}
}
public List <ListViewItem> LoadDatasetVersionViewList(DataStructureType dataStructureType)
{
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
DataStructureManager dataStructureManager = new DataStructureManager();
DatasetManager dm = new DatasetManager();
try
{
ICollection <long> datasetIDs = new List <long>();
datasetIDs = entityPermissionManager.GetKeys(GetUsernameOrDefault(), "Dataset", typeof(Dataset), RightType.Write).ToList();
Dictionary <long, XmlDocument> dmtemp = new Dictionary <long, XmlDocument>();
dmtemp = dm.GetDatasetLatestMetadataVersions();
List <ListViewItem> temp = new List <ListViewItem>();
if (dataStructureType.Equals(DataStructureType.Structured))
{
List <StructuredDataStructure> list = dataStructureManager.StructuredDataStructureRepo.Get().ToList();
foreach (StructuredDataStructure sds in list)
{
sds.Materialize();
foreach (Dataset d in sds.Datasets)
{
if (dm.IsDatasetCheckedIn(d.Id))
{
if (datasetIDs.Contains(d.Id))
{
temp.Add(new ListViewItem(d.Id,
xmlDatasetHelper.GetInformationFromVersion(dm.GetDatasetLatestVersion(d).Id,
NameAttributeValues.title)));
}
}
}
}
}
else
{
List <UnStructuredDataStructure> list = dataStructureManager.UnStructuredDataStructureRepo.Get().ToList();
foreach (UnStructuredDataStructure sds in list)
{
foreach (Dataset d in sds.Datasets)
{
if (datasetIDs.Contains(d.Id))
{
if (dm.IsDatasetCheckedIn(d.Id))
{
DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(d);
temp.Add(new ListViewItem(d.Id,
xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title)));
}
}
}
}
}
return(temp.OrderBy(p => p.Title).ToList());
}
finally
{
entityPermissionManager.Dispose();
dataStructureManager.Dispose();
dm.Dispose();
}
}
public async Task <ActionResult> SendDataToDataRepo(long datasetId, string datarepo)
{
PublicationManager publicationManager = new PublicationManager();
DatasetManager datasetManager = new DatasetManager();
try
{
string zipfilepath = "";
if (Session["ZipFilePath"] != null)
{
zipfilepath = Session["ZipFilePath"].ToString();
}
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
Publication publication =
publicationManager.GetPublication()
.Where(
p =>
p.DatasetVersion.Id.Equals(datasetVersion.Id) &&
p.Broker.Name.ToLower().Equals(datarepo.ToLower()))
.FirstOrDefault();
if (publication == null)
{
//ToDo [SUBMISSION] -> create broker specfic function
// check case for gfbio
if (datarepo.ToLower().Contains("gfbio"))
{
#region GFBIO
//SubmissionManager publishingManager = new SubmissionManager();
//publishingManager.Load();
//DataRepository dataRepository = publishingManager.DataRepositories.Where(d => d.Name.Equals(datarepo)).FirstOrDefault();
Broker broker =
publicationManager.GetBroker()
.Where(b => b.Name.ToLower().Equals(datarepo.ToLower()))
.FirstOrDefault();
if (broker != null)
{
//Store ro in db
string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id,
NameAttributeValues.title);
publicationManager.CreatePublication(datasetVersion, broker, title, 0, zipfilepath, "", "no status available");
//sendToGFBIO(broker, datasetId, datasetVersion, zipfilepath);
}
#endregion
}
if (datarepo.ToLower().Contains("pensoft"))
{
#region pensoft
Broker broker =
publicationManager.BrokerRepo.Get()
.Where(b => b.Name.ToLower().Equals(datarepo.ToLower()))
.FirstOrDefault();
Repository repository =
publicationManager.RepositoryRepo.Get()
.Where(b => b.Name.ToLower().Equals(datarepo.ToLower()))
.FirstOrDefault();
string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title);
publicationManager.CreatePublication(datasetVersion, broker, repository, title, 0, zipfilepath, "",
"no status available");
#endregion
}
if (datarepo.ToLower().Equals("generic"))
{
#region GENERIC
Broker broker =
publicationManager.BrokerRepo.Get()
.Where(b => b.Name.ToLower().Equals(datarepo.ToLower()))
.FirstOrDefault();
string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title);
publicationManager.CreatePublication(datasetVersion, broker, title, 0, zipfilepath, "",
"created");
#endregion
}
}
else
{
Json("Publication exist.");
}
}
catch (Exception ex)
{
return(Json(ex.Message));
}
finally
{
publicationManager.Dispose();
datasetManager.Dispose();
}
return(Json(true));
}
/// <summary>
/// Submit a Dataset based on the imformations
/// in the CreateTaskManager
/// </summary>
public long SubmitDataset(bool valid)
{
#region create dataset
DatasetManager dm = new DatasetManager();
DataStructureManager dsm = new DataStructureManager();
ResearchPlanManager rpm = new ResearchPlanManager();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
string title = "";
long datasetId = 0;
bool newDataset = true;
try
{
TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
if (TaskManager.Bus.ContainsKey(CreateTaskmanager.DATASTRUCTURE_ID) &&
TaskManager.Bus.ContainsKey(CreateTaskmanager.RESEARCHPLAN_ID) &&
TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATASTRUCTURE_ID))
{
// for e new dataset
if (!TaskManager.Bus.ContainsKey(CreateTaskmanager.ENTITY_ID))
{
long datastructureId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.DATASTRUCTURE_ID]);
long researchPlanId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.RESEARCHPLAN_ID]);
long metadataStructureId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.METADATASTRUCTURE_ID]);
DataStructure dataStructure = dsm.StructuredDataStructureRepo.Get(datastructureId);
//if datastructure is not a structured one
if (dataStructure == null)
{
dataStructure = dsm.UnStructuredDataStructureRepo.Get(datastructureId);
}
ResearchPlan rp = rpm.Repo.Get(researchPlanId);
MetadataStructureManager msm = new MetadataStructureManager();
MetadataStructure metadataStructure = msm.Repo.Get(metadataStructureId);
var ds = dm.CreateEmptyDataset(dataStructure, rp, metadataStructure);
datasetId = ds.Id;
// add security
if (GetUsernameOrDefault() != "DEFAULT")
{
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
entityPermissionManager.Create <User>(GetUsernameOrDefault(), "Dataset", typeof(Dataset), ds.Id, Enum.GetValues(typeof(RightType)).Cast <RightType>().ToList());
}
}
else
{
datasetId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.ENTITY_ID]);
newDataset = false;
}
TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
if (dm.IsDatasetCheckedOutFor(datasetId, GetUsernameOrDefault()) || dm.CheckOutDataset(datasetId, GetUsernameOrDefault()))
{
DatasetVersion workingCopy = dm.GetDatasetWorkingCopy(datasetId);
if (TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATA_XML))
{
XDocument xMetadata = (XDocument)TaskManager.Bus[CreateTaskmanager.METADATA_XML];
workingCopy.Metadata = Xml.Helpers.XmlWriter.ToXmlDocument(xMetadata);
}
//set status
if (workingCopy.StateInfo == null)
{
workingCopy.StateInfo = new Vaiona.Entities.Common.EntityStateInfo();
}
if (valid)
{
workingCopy.StateInfo.State = DatasetStateInfo.Valid.ToString();
}
else
{
workingCopy.StateInfo.State = DatasetStateInfo.NotValid.ToString();
}
title = xmlDatasetHelper.GetInformationFromVersion(workingCopy.Id, NameAttributeValues.title);
if (string.IsNullOrEmpty(title))
{
title = "No Title available.";
}
TaskManager.AddToBus(CreateTaskmanager.ENTITY_TITLE, title);//workingCopy.Metadata.SelectNodes("Metadata/Description/Description/Title/Title")[0].InnerText);
TaskManager.AddToBus(CreateTaskmanager.ENTITY_ID, datasetId);
dm.EditDatasetVersion(workingCopy, null, null, null);
dm.CheckInDataset(datasetId, "Metadata was submited.", GetUsernameOrDefault(), ViewCreationBehavior.None);
//add to index
// ToDo check which SearchProvider it is, default luceneprovider
// BUG: invalid call to ddm method
// TODO: mODULARITY ->Call DDM Reindex
/*
* <Export tag="internalApi" id="SearchIndex"
* title="Reindex Search" description="Reindex Search" icon=""
* controller="SearchIndex" action="Get"
* extends="" />
*/
// WORKAROUND: do not reindex
//ISearchProvider provider = IoCFactory.Container.ResolveForSession<ISearchProvider>() as ISearchProvider;
//provider?.UpdateSingleDatasetIndex(datasetId, IndexingAction.CREATE);
if (this.IsAccessibale("DDM", "SearchIndex", "ReIndexSingle"))
{
var x = this.Run("DDM", "SearchIndex", "ReIndexSingle", new RouteValueDictionary()
{
{ "id", datasetId }
});
}
LoggerFactory.LogData(datasetId.ToString(), typeof(Dataset).Name, Vaiona.Entities.Logging.CrudState.Created);
if (newDataset)
{
var es = new EmailService();
es.Send(MessageHelper.GetCreateDatasetHeader(),
MessageHelper.GetCreateDatasetMessage(datasetId, title, GetUsernameOrDefault()),
ConfigurationManager.AppSettings["SystemEmail"]
);
}
else
{
var es = new EmailService();
es.Send(MessageHelper.GetUpdateDatasetHeader(),
MessageHelper.GetUpdateDatasetMessage(datasetId, title, GetUsernameOrDefault()),
ConfigurationManager.AppSettings["SystemEmail"]
);
}
}
return(datasetId);
}
}
catch (Exception ex)
{
var es = new EmailService();
es.Send(MessageHelper.GetUpdateDatasetHeader(),
ex.Message,
ConfigurationManager.AppSettings["SystemEmail"]
);
}
finally
{
dm.Dispose();
rpm.Dispose();
dsm.Dispose();
}
#endregion create dataset
return(-1);
}
public ActionResult StoreSelectedDatasetSetup(SetupModel model)
{
CreateTaskmanager TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
DatasetManager datasetManager = new DatasetManager();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
try
{
if (model == null)
{
model = GetDefaultModel();
return(PartialView("Index", model));
}
model = LoadLists(model);
if (ModelState.IsValid)
{
TaskManager.AddToBus(CreateTaskmanager.METADATASTRUCTURE_ID, model.SelectedMetadataStructureId);
TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_ID, model.SelectedDataStructureId);
// set datastructuretype
TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_TYPE, GetDataStructureType(model.SelectedDataStructureId));
//dataset is selected
if (model.SelectedDatasetId != 0 && model.SelectedDatasetId != -1)
{
if (datasetManager.IsDatasetCheckedIn(model.SelectedDatasetId))
{
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(model.SelectedDatasetId);
TaskManager.AddToBus(CreateTaskmanager.RESEARCHPLAN_ID,
datasetVersion.Dataset.ResearchPlan.Id);
TaskManager.AddToBus(CreateTaskmanager.ENTITY_TITLE,
xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title));
// set datastructuretype
TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_TYPE,
GetDataStructureType(model.SelectedDataStructureId));
// set MetadataXml From selected existing Dataset
XDocument metadata = XmlUtility.ToXDocument(datasetVersion.Metadata);
SetXml(metadata);
}
else
{
ModelState.AddModelError(string.Empty, "Dataset is just in processing");
}
}
else
{
ResearchPlanManager rpm = new ResearchPlanManager();
TaskManager.AddToBus(CreateTaskmanager.RESEARCHPLAN_ID, rpm.Repo.Get().First().Id);
}
return(RedirectToAction("StartMetadataEditor", "Form"));
}
return(View("Index", model));
}
finally
{
datasetManager.Dispose();
}
}
