/// <summary>
/// Check if revision is correct
/// </summary>
/// <param name="inputRevisionId"></param>
/// <param name="taxonRevision"></param>
/// <returns></returns>
protected bool CheckRevisionValidity(string inputRevisionId, ITaxonRevision taxonRevision)
{
string errorMsg;
bool valid = true;
if (taxonRevision.IsNull())
{
errorMsg = Resources.DyntaxaResource.RevisionAddInvalidRevisionErrorText;
ModelState.AddModelError("", errorMsg);
valid = false;
}
if (taxonRevision.IsNotNull() && !taxonRevision.Id.ToString().Equals(inputRevisionId))
{
errorMsg = Resources.DyntaxaResource.RevisionSharedNoValidRevisionIdErrorText;
string propName = string.Empty;
string propValue = string.Empty;
if (taxonRevision.IsNotNull())
{
propName = ReflectionUtility.GetPropertyName(() => taxonRevision.Id);
PropertyInfo pi = taxonRevision.GetType().GetProperty(propName);
propValue = pi.GetValue(taxonRevision, null).ToString();
ModelState.AddModelError("", errorMsg + " " + propValue);
}
else
{
ModelState.AddModelError("", errorMsg);
}
valid = false;
}
return(valid);
}
public RevisionTaxonInfoViewModel GetRevisionInfoViewModel(ITaxon revisionTaxon, ITaxonRevision taxonRevision)
{
RevisionTaxonInfoViewModel revisionTaxonInfoViewModel = new RevisionTaxonInfoViewModel();
if (revisionTaxon.IsNotNull())
{
revisionTaxonInfoViewModel.CommonName = revisionTaxon.CommonName.IsNotEmpty()
? revisionTaxon.CommonName
: string.Empty;
revisionTaxonInfoViewModel.ScientificName = revisionTaxon.ScientificName;
revisionTaxonInfoViewModel.Category = revisionTaxon.Category.Name;
revisionTaxonInfoViewModel.CategorySortOrder = revisionTaxon.Category.SortOrder;
}
else
{
revisionTaxonInfoViewModel.CommonName = string.Empty;
revisionTaxonInfoViewModel.ScientificName = string.Empty;
revisionTaxonInfoViewModel.Category = string.Empty;
revisionTaxonInfoViewModel.CategorySortOrder = 0;
}
if (taxonRevision.IsNotNull())
{
revisionTaxonInfoViewModel.Id = taxonRevision.Id.ToString();
}
else
{
revisionTaxonInfoViewModel.Id = "0";
}
revisionTaxonInfoViewModel.RevisionText = Resources.DyntaxaResource.SharedRevisionIdLabelText;
revisionTaxonInfoViewModel.MainHeaderText = Resources.DyntaxaResource.RevisionListEventMainHeaderlText;
return(revisionTaxonInfoViewModel);
}
/// <summary>
///
/// </summary>
/// <param name="loggedInUser"></param>
/// <param name="dyntaxaApplicationUserContext"></param>
/// <param name="taxonRevision"></param>
/// <param name="isTaxonInRevision"></param>
/// <param name="revisionUsers"></param>
/// <param name="allUsers"></param>
/// <param name="roleId"></param>
/// <returns></returns>
public RevisionEditViewModel GetRevisionEditViewModel(
IUserContext loggedInUser,
IUserContext dyntaxaApplicationUserContext,
ITaxonRevision taxonRevision,
ITaxon taxon,
bool isTaxonInRevision,
IList <RevisionUserItemModelHelper> revisionUsers,
IList <RevisionUserItemModelHelper> allUsers,
int roleId)
{
RevisionEditViewModel model = new RevisionEditViewModel();
if (loggedInUser.IsNotNull() && dyntaxaApplicationUserContext.IsNotNull())
{
// Set locale to logged in user.
dyntaxaApplicationUserContext.Locale = loggedInUser.Locale;
if (taxonRevision.IsNotNull())
{
if (taxon.IsNotNull())
{
model.ExpectedStartDate = taxonRevision.ExpectedStartDate;
model.ExpectedPublishingDate = taxonRevision.ExpectedEndDate;
model.IsSpeciesFactPublished = taxonRevision.IsSpeciesFactPublished;
model.IsReferenceRelationsPublished = taxonRevision.IsReferenceRelationsPublished;
model.GUID = taxonRevision.Guid;
model.RevisionReferencesList = new List <int>();
model.NoOfRevisionReferences = 0;
foreach (ReferenceRelation referenceRelation in taxonRevision.GetReferences(loggedInUser))
{
model.RevisionReferencesList.Add(referenceRelation.Id);
model.NoOfRevisionReferences++;
}
model.SelectedUserList = new List <RevisionUserItemModelHelper>();
model.UserList = new List <RevisionUserItemModelHelper>();
foreach (RevisionUserItemModelHelper user in allUsers)
{
bool userAssigedToRevision = false;
foreach (RevisionUserItemModelHelper revisionUser in revisionUsers)
{
if (user.Id == revisionUser.Id)
{
//We found a alreday assigned user
userAssigedToRevision = true;
break;
}
}
if (userAssigedToRevision)
{
model.SelectedUserList.Add(user);
}
else
{
model.UserList.Add(user);
}
}
string url = Resources.DyntaxaResource.SharedRevisionUserAdminLinkText;
model.RoleId = roleId.ToString();
model.UserAdminLink = new LinkItem(LinkType.Url, LinkQuality.Automatic, url, userAdminRoleLink);
model.RevisionDescription = taxonRevision.Description;
// Get specices fact information
try
{
SpeciesFactModelManager speciesModel = new SpeciesFactModelManager(taxon, loggedInUser);
try
{
if (speciesModel.QualityStatus.IsNotNull())
{
model.RevisionQualityId = speciesModel.QualityStatus.Id;
}
else if (speciesModel.QualityStatusList.IsNotNull() && speciesModel.QualityStatusList.Count > 1)
{
model.RevisionQualityId = speciesModel.QualityStatusList.ElementAt(0).Id;
}
else
{
model.RevisionQualityId = 0;
}
model.RevisionQualityList = new List <TaxonDropDownModelHelper>();
foreach (var status in speciesModel.QualityStatusList)
{
model.RevisionQualityList.Add(new TaxonDropDownModelHelper(status.Id, status.Label));
}
model.RevisionQualityDescription = speciesModel.QualityDescription;
}
catch (Exception)
{
model.ErrorMessage = Resources.DyntaxaResource.SharedNotPossibleToReadSpeciesFactError;
}
}
catch (Exception)
{
model.ErrorMessage = Resources.DyntaxaResource.SharedNotPossibleToReadSpeciesFactError;
}
model.RevisionTaxonInfoViewModel = new RevisionTaxonInfoViewModel();
model.RevisionTaxonInfoViewModel.Id = taxonRevision.Id.ToString();
model.RevisionTaxonInfoViewModel.CommonName = taxon.CommonName.IsNotEmpty() ? taxon.CommonName : string.Empty;
model.RevisionTaxonInfoViewModel.ScientificName = taxon.ScientificName;
model.RevisionTaxonInfoViewModel.Category = taxon.Category.Name;
model.RevisionTaxonInfoViewModel.CategorySortOrder = taxon.Category.SortOrder;
model.RevisionTaxonInfoViewModel.RevisionText = Resources.DyntaxaResource.SharedRevisionIdLabelText;
model.RevisionTaxonInfoViewModel.MainHeaderText = Resources.DyntaxaResource.RevisionEditMainHeaderFullText;
model.RevisionId = taxonRevision.Id.ToString();
model.ShowFinalizeButton = false;
model.ShowInitalizeButton = false;
model.ShowDeleteButton = false;
ITaxon revisionTaxon = taxonRevision.RootTaxon;
int state = taxonRevision.State.Id;
if (state == (int)TaxonRevisionStateId.Created)
{
model.RevisionStatus = Resources.DyntaxaResource.RevisionListSelectedRevisionStatusCreatedText;
model.ShowInitalizeButton = true;
model.IsTaxonInRevision = revisionTaxon.IsInRevision;
model.ShowDeleteButton = true;
}
else if (state == (int)TaxonRevisionStateId.Ongoing)
{
model.RevisionStatus = Resources.DyntaxaResource.RevisionListSelectedRevisionStatusOngoingText;
model.ShowFinalizeButton = true;
}
else if (state == (int)TaxonRevisionStateId.Closed)
{
model.RevisionStatus = Resources.DyntaxaResource.RevisionListSelectedRevisionStatusClosedText;
model.ShowUpdateSpeciesFactButton = !taxonRevision.IsSpeciesFactPublished;
model.ShowUpdateReferenceRelationsButton = !taxonRevision.IsReferenceRelationsPublished;
}
model.RevisionTaxonId = revisionTaxon.Id.ToString();
return(model);
}
else
{
model.ErrorMessage = Resources.DyntaxaResource.RevisonAddInvalidTaxonErrorText;
}
}
else
{
model.ErrorMessage = Resources.DyntaxaResource.RevisionSharedNoValidRevisionIdErrorText + taxonRevision.Id + ".";
}
}
else
{
model.ErrorMessage = Resources.DyntaxaResource.SharedInvalidUserContext + " " + Resources.DyntaxaResource.SharedInvalidApplicationUserContext;
}
return(model);
}
public RevisionEditViewModel ReloadRevisionEditViewModel(
IUserContext userContext,
IUserContext dyntaxaApplicationUserContext,
ITaxon taxon,
ITaxonRevision taxonRevision,
RevisionEditViewModel model,
IList <RevisionUserItemModelHelper> revisionUsers,
IList <RevisionUserItemModelHelper> allUsers)
{
IUserContext loggedInUser = userContext;
model.RevisionQualityList = new List <TaxonDropDownModelHelper>();
model.SelectedUserList = new List <RevisionUserItemModelHelper>();
model.UserList = new List <RevisionUserItemModelHelper>();
model.RevisionReferencesList = new List <int>();
model.RevisionTaxonInfoViewModel = new RevisionTaxonInfoViewModel();
if (loggedInUser.IsNotNull() && dyntaxaApplicationUserContext.IsNotNull())
{
if (taxonRevision.IsNotNull())
{
foreach (ReferenceRelation referenceRelation in taxonRevision.GetReferences(userContext))
{
model.RevisionReferencesList.Add(referenceRelation.Id);
}
}
foreach (RevisionUserItemModelHelper user in allUsers)
{
bool userAssigedToRevision = false;
if (revisionUsers.IsNotNull())
{
foreach (RevisionUserItemModelHelper revisionUser in revisionUsers)
{
if (user.Id == revisionUser.Id)
{
//We found a alreday assigned user
userAssigedToRevision = true;
break;
}
}
}
if (userAssigedToRevision)
{
model.SelectedUserList.Add(user);
}
else
{
model.UserList.Add(user);
}
}
if (taxon.IsNotNull())
{
SpeciesFactModelManager speciesModel = new SpeciesFactModelManager(taxon, loggedInUser);
foreach (var status in speciesModel.QualityStatusList)
{
model.RevisionQualityList.Add(new TaxonDropDownModelHelper(status.Id, status.Label));
}
}
if (taxon.IsNotNull() && taxonRevision.IsNotNull())
{
model.RevisionTaxonInfoViewModel = new RevisionTaxonInfoViewModel();
model.RevisionTaxonInfoViewModel.Id = taxonRevision.Id.ToString();
model.RevisionTaxonInfoViewModel.CommonName = taxon.CommonName.IsNotEmpty() ? taxon.CommonName : string.Empty;
model.RevisionTaxonInfoViewModel.ScientificName = taxon.ScientificName;
model.RevisionTaxonInfoViewModel.Category = taxon.Category.Name;
model.RevisionTaxonInfoViewModel.CategorySortOrder = taxon.Category.SortOrder;
model.RevisionTaxonInfoViewModel.RevisionText = Resources.DyntaxaResource.SharedRevisionIdLabelText;
model.RevisionTaxonInfoViewModel.MainHeaderText = Resources.DyntaxaResource.RevisionEditMainHeaderFullText;
}
string url = Resources.DyntaxaResource.SharedRevisionUserAdminLinkText;
model.UserAdminLink = new LinkItem(LinkType.Url, LinkQuality.Automatic, url, userAdminRoleLink);
}
else
{
model.ErrorMessage = Resources.DyntaxaResource.SharedInvalidUserContext + " " + Resources.DyntaxaResource.SharedInvalidApplicationUserContext;
}
return(model);
}
/// <summary>
/// Get all taxa that are possible parents for this taxon.
/// </summary>
/// <param name="taxon">The taxon.</param>
/// <param name="userContext">User context.</param>
/// <param name="taxonRevision">Revision that this taxon belongs to.</param>
/// <returns>List of taxa that are possible parent taxa.</returns>
public static TaxonList GetTaxaPossibleParents(
this ITaxon taxon,
IUserContext userContext,
ITaxonRevision taxonRevision)
{
ITaxonCategory genusTaxonCategory;
ITaxonTreeNode revisionTaxonTree;
TaxonList parentTaxa, possibleParents, revisionTaxa;
possibleParents = new TaxonList(true);
if (taxonRevision.IsNotNull())
{
genusTaxonCategory = CoreData.TaxonManager.GetTaxonCategory(userContext, TaxonCategoryId.Genus);
revisionTaxonTree = taxonRevision.RootTaxon.GetChildTaxonTree(userContext, true);
revisionTaxa = revisionTaxonTree.GetChildTaxa();
// Add revision root taxon if it doesn't exist in revisionTaxa list.
if (!revisionTaxa.Exists(taxonRevision.RootTaxon))
{
revisionTaxa.Add(taxonRevision.RootTaxon);
}
parentTaxa = new TaxonList();
GetParentTaxa(revisionTaxonTree, taxon, parentTaxa);
revisionTaxa.RemoveAll(x => parentTaxa.Contains(x));
revisionTaxa.SortTaxonCategory();
return(revisionTaxa);
//foreach (ITaxon revisionTaxon in revisionTaxa)
//{
// possibleParents.Merge(revisionTaxon);
// continue;
// // add all taxa that has IsTaxonomic = false to the list of possibleParents -- GuNy 2013-01-09
// if (!revisionTaxon.Category.IsTaxonomic && !parentTaxa.Exists(revisionTaxon))
// {
// possibleParents.Merge(revisionTaxon);
// }
// // all taxa that is below taxon.Category is removed
// else if ((revisionTaxon.Category.SortOrder < taxon.Category.SortOrder) &&
// !parentTaxa.Exists(revisionTaxon))
// {
// if (genusTaxonCategory.SortOrder < taxon.Category.SortOrder)
// {
// // Limit possible parents to max genus taxon category.
// // If the taxon you want to move is below genus then you can only
// // move it to taxa that is of genus category or below.
// if (genusTaxonCategory.SortOrder <= revisionTaxon.Category.SortOrder)
// {
// possibleParents.Merge(revisionTaxon);
// }
// }
// else
// {
// // Include all possible parents from higher taxon categories.
// possibleParents.Merge(revisionTaxon);
// }
// }
//}
//possibleParents.SortTaxonCategory();
}
return(possibleParents);
}
