public void GetDyntaxaRevisionSpeciesFact_WhenRowDoesNotExist_ThenNullIsReturned()
        {
            DyntaxaRevisionSpeciesFact currentDyntaxaRevisionSpeciesFact;
            Int32 revisionId = -5000;
            Int32 taxonId    = -50;

            IUserContext userContext = GetUserContext();
            DyntaxaInternalTaxonServiceManager manager = new DyntaxaInternalTaxonServiceManager();

            using (ITransaction transaction = userContext.StartTransaction())
            {
                currentDyntaxaRevisionSpeciesFact = manager.GetDyntaxaRevisionSpeciesFact(userContext, (Int32)FactorId.SwedishHistory, taxonId, revisionId);

                Assert.IsNull(currentDyntaxaRevisionSpeciesFact);
            }
        }
예제 #2
0
        //private static IPerson GetCreatedByPerson(IUserContext userContext, int createdBy)
        //{
        //    IPerson person;
        //    IUser user;

        //    try
        //    {
        //        user = CoreData.UserManager.GetUser(userContext, createdBy);
        //    }
        //    catch (Exception)
        //    {
        //        // user does not exist in UserAdmin system
        //        user = null;
        //    }

        //    if ((user.IsNotNull()) &&
        //        (user.Type == UserType.Person) &&
        //        (user.PersonId.HasValue))
        //    {
        //        person = CoreData.UserManager.GetPerson(userContext, user.PersonId.Value);
        //    }
        //    else
        //    {
        //        person = null;
        //    }
        //    return person;
        //}

        /// <summary>
        /// The create.
        /// </summary>
        /// <param name="userContext">
        /// The user context.
        /// </param>
        /// <param name="taxon">
        /// The taxon.
        /// </param>
        /// <param name="revisionId">
        /// The revision id.
        /// </param>
        /// <returns>
        /// The <see cref="TaxonSummaryViewModel"/>.
        /// </returns>
        public static TaxonSummaryViewModel Create(IUserContext userContext, ITaxon taxon, int?revisionId)
        {
            var     model = new TaxonSummaryViewModel();
            IPerson person;
            bool    isInRevision      = DyntaxaHelper.IsInRevision(userContext, revisionId);
            bool    isUserTaxonEditor = userContext.IsTaxonEditor();

            model.Id                = taxon.Id.ToString();
            model.Guid              = taxon.Guid ?? string.Empty;
            model.CategoryId        = taxon.Category != null ? taxon.Category.Id : 0;
            model.Category          = taxon.Category != null ? taxon.Category.Name : string.Empty;
            model.IsMicrospecies    = taxon.IsMicrospecies;
            model.CategorySortOrder = taxon.Category != null ? taxon.Category.SortOrder : 0;
            model.ConceptDefinition = taxon.GetConceptDefinition(userContext) ?? "-";
            model.AlertStatus       = (TaxonAlertStatusId)taxon.AlertStatus.Id;
            model.AlertImageUrl     = GetAlertImageUrl(model.AlertStatus);
            person = taxon.GetModifiedByPerson(userContext);
            //IPerson createdByPerson = GetCreatedByPerson(userContext, taxon.CreatedBy);
            //string createdFullName = createdByPerson.FullName;
            if (person.IsNull())
            {
                model.UpdateInformation = string.Format("{0} ({1})", taxon.ModifiedDate.ToShortDateString(), String.Empty);
            }
            else
            {
                model.UpdateInformation = string.Format("{0} ({1})", taxon.ModifiedDate.ToShortDateString(), person.FullName);
            }

            model.ValidToInformation = string.Format("{0} ({1})", taxon.ValidToDate.ToShortDateString(), taxon.ModifiedByPerson);
            model.CreatedInformation = string.Format("{0} ({1})", taxon.CreatedDate.ToShortDateString(), taxon.ModifiedByPerson);
            model.Validity           = GetValidityDescription(taxon);

            if (taxon.ScientificName.IsNotEmpty())
            {
                model.ScientificName = new TaxonNameAuthorViewModel(taxon.ScientificName, taxon.Author);
            }

            if (taxon.CommonName.IsNotEmpty())
            {
                model.CommonName = new TaxonNameAuthorViewModel(taxon.CommonName, string.Empty);
            }

            // Synonyms
            //model.Synonyms = new List<TaxonNameViewModel>();
            //var synonyms = taxon.GetSynonyms(userContext, true);
            //if (synonyms != null)
            //{
            //    foreach (ITaxonName taxonName in synonyms)
            //    {
            //        model.Synonyms.Add(new TaxonNameViewModel(taxonName, taxon));
            //    }
            //}

            model.Synonyms         = taxon.GetSynonymsViewModel(isInRevision, isUserTaxonEditor, false);
            model.ProParteSynonyms = taxon.GetProParteSynonymsViewModel(isInRevision, isUserTaxonEditor);
            model.MisappliedNames  = taxon.GetMisappliedNamesViewModel(isInRevision, isUserTaxonEditor);

            // Other valid common names
            // todo - change implementation?
            //model.OtherValidCommonNames = new List<string>();
            //if (!taxon.CommonName.IsEmpty())
            //{
            //    model.OtherValidCommonNames.AddRange(
            //        from taxonName in taxon.GetTaxonNames(userContext)
            //        where
            //            taxonName.Category.Id == (int)TaxonNameCategoryId.SwedishName &&
            //            taxonName.Version != taxon.GetCommonName(userContext).Version
            //        select taxonName.Name);

            //    // todo - även ha med att namnet är gilitigt. Hur ser man det???
            //}

            model.OtherValidCommonNames = taxon.GetNotRecommendedSwedishNamesViewModel(isInRevision, isUserTaxonEditor);

            // Remove other valid common names from synonyms
            if (model.OtherValidCommonNames.IsNotEmpty())
            {
                List <TaxonNameViewModel> newSynonymList = new List <TaxonNameViewModel>();

                foreach (TaxonNameViewModel synonym in model.Synonyms)
                {
                    if (model.OtherValidCommonNames.All(x => x.Id != synonym.Id))
                    {
                        newSynonymList.Add(synonym);
                    }
                }

                model.Synonyms = newSynonymList;
            }

            // Classification
            var allParentTaxa      = taxon.GetAllParentTaxonRelations(userContext, null, isInRevision, false, true);
            var distinctParentTaxa = allParentTaxa.GroupBy(x => x.ParentTaxon.Id).Select(x => x.First().ParentTaxon).ToList();

            model.Classification = new List <RelatedTaxonViewModel>();
            foreach (ITaxon relatedTaxon in distinctParentTaxa)
            {
                if (relatedTaxon.Category.IsTaxonomic)
                {
                    model.Classification.Add(new RelatedTaxonViewModel(relatedTaxon, relatedTaxon.Category, null));
                }
            }

            // Species fact
            try
            {
                // Dictionary<FactorId, SpeciesFact> dicSpeciesFacts = SpeciesFactHelper.GetSpeciesFacts(taxon, new [] {FactorId.SwedishOccurence, FactorId.SwedishHistory});
                Dictionary <FactorId, SpeciesFact> dicSpeciesFacts = SpeciesFactHelper.GetCommonDyntaxaSpeciesFacts(userContext, taxon);
                model.SwedishHistory    = SpeciesFactHelper.GetFactorValue(dicSpeciesFacts, FactorId.SwedishHistory);
                model.SwedishOccurrence = SpeciesFactHelper.GetFactorValue(dicSpeciesFacts, FactorId.SwedishOccurrence);

                // If swedish occurrence or swedish history is changed in the current revision, then show those values instead.
                if (DyntaxaHelper.IsInRevision(userContext, revisionId))
                {
                    DyntaxaInternalTaxonServiceManager internalTaxonServiceManager =
                        new DyntaxaInternalTaxonServiceManager();

                    // Check if Swedish occurrence is stored in Taxon database in this revision.
                    DyntaxaRevisionSpeciesFact swedishOccurrenceRevisionSpeciesFact =
                        internalTaxonServiceManager.GetDyntaxaRevisionSpeciesFact(
                            userContext,
                            (Int32)FactorId.SwedishOccurrence,
                            taxon.Id,
                            revisionId.Value);
                    if (swedishOccurrenceRevisionSpeciesFact != null)
                    {
                        SpeciesFactModelManager speciesFactModel = new SpeciesFactModelManager(taxon, userContext);
                        TaxonModelManager.UpdateOldSpeciesFactModelWithDyntaxaRevisionSpeciesFactValues(userContext, speciesFactModel.SwedishOccurrenceSpeciesFact, swedishOccurrenceRevisionSpeciesFact);
                        model.SwedishOccurrence = speciesFactModel.SwedishOccurrenceSpeciesFact.GetStatusOriginalLabel();
                    }

                    // Check if Swedish history is stored in Taxon database in this revision.
                    DyntaxaRevisionSpeciesFact swedishHistoryRevisionSpeciesFact =
                        internalTaxonServiceManager.GetDyntaxaRevisionSpeciesFact(
                            userContext,
                            (Int32)FactorId.SwedishHistory,
                            taxon.Id,
                            revisionId.Value);
                    if (swedishHistoryRevisionSpeciesFact != null)
                    {
                        if (swedishHistoryRevisionSpeciesFact.StatusId.HasValue)
                        {
                            SpeciesFactModelManager speciesFactModel = new SpeciesFactModelManager(taxon, userContext);
                            TaxonModelManager.UpdateOldSpeciesFactModelWithDyntaxaRevisionSpeciesFactValues(userContext, speciesFactModel.SwedishHistorySpeciesFact, swedishHistoryRevisionSpeciesFact);
                            model.SwedishHistory = speciesFactModel.SwedishHistorySpeciesFact.GetStatusOriginalLabel();
                        }
                        else // swedish history is deleted in this revision
                        {
                            model.SwedishHistory = "";
                        }
                    }
                }
            }
            catch (Exception)
            {
                // the taxon did not exist in Artfakta
            }

            return(model);
        }
        /// <summary>
        /// Creates a swedish occurrence summary view model.
        /// </summary>
        /// <param name="taxon">The taxon.</param>
        /// <returns></returns>
        public SwedishOccurrenceSummaryViewModel CreateSwedishOccurrenceSummaryViewModel(ITaxon taxon)
        {
            var model        = new SwedishOccurrenceSummaryViewModel();
            int?redListValue = null;

            // Species fact
            try
            {
                Dictionary <ArtDatabanken.Data.FactorId, ArtDatabanken.Data.SpeciesFact> dicSpeciesFacts = SpeciesFactHelper.GetCommonDyntaxaSpeciesFacts(this._userContext, taxon);
                if (dicSpeciesFacts.ContainsKey(FactorId.SwedishHistory))
                {
                    model.SwedishHistory     = SpeciesFactHelper.GetFactorValue(dicSpeciesFacts, ArtDatabanken.Data.FactorId.SwedishHistory);
                    model.SwedishHistoryFact = dicSpeciesFacts[FactorId.SwedishHistory];
                }

                if (dicSpeciesFacts.ContainsKey(FactorId.SwedishOccurrence))
                {
                    //CoreData.SpeciesFactManager.GetSpeciesFact()
                    model.SwedishOccurrence     = SpeciesFactHelper.GetFactorValue(dicSpeciesFacts, ArtDatabanken.Data.FactorId.SwedishOccurrence);
                    model.SwedishOccurrenceFact = dicSpeciesFacts[FactorId.SwedishOccurrence];
                }

                if (dicSpeciesFacts.ContainsKey(FactorId.RedlistCategory))
                {
                    model.RedListInfo = GetRedListCategory(dicSpeciesFacts[ArtDatabanken.Data.FactorId.RedlistCategory]);
                    redListValue      = GetRedListCategoryValue(dicSpeciesFacts[ArtDatabanken.Data.FactorId.RedlistCategory]);
                }

                // If swedish occurrence or swedish history is changed in the current revision, then show those values instead.
                if (DyntaxaHelper.IsInRevision(_userContext, _taxonRevision))
                {
                    DyntaxaInternalTaxonServiceManager internalTaxonServiceManager =
                        new DyntaxaInternalTaxonServiceManager();

                    // Check if Swedish occurrence is stored in Taxon database in this revision.
                    DyntaxaRevisionSpeciesFact swedishOccurrenceRevisionSpeciesFact =
                        internalTaxonServiceManager.GetDyntaxaRevisionSpeciesFact(
                            _userContext,
                            (Int32)FactorId.SwedishOccurrence,
                            taxon.Id,
                            _taxonRevision.Id);
                    if (swedishOccurrenceRevisionSpeciesFact != null)
                    {
                        SpeciesFactModelManager speciesFactModel = new SpeciesFactModelManager(taxon, _userContext);
                        TaxonModelManager.UpdateOldSpeciesFactModelWithDyntaxaRevisionSpeciesFactValues(_userContext, speciesFactModel.SwedishOccurrenceSpeciesFact, swedishOccurrenceRevisionSpeciesFact);
                        model.SwedishOccurrence     = speciesFactModel.SwedishOccurrenceSpeciesFact.GetStatusOriginalLabel();
                        model.SwedishOccurrenceFact = speciesFactModel.SwedishOccurrenceSpeciesFact;
                    }

                    // Check if Swedish history is stored in Taxon database in this revision.
                    DyntaxaRevisionSpeciesFact swedishHistoryRevisionSpeciesFact =
                        internalTaxonServiceManager.GetDyntaxaRevisionSpeciesFact(
                            _userContext,
                            (Int32)FactorId.SwedishHistory,
                            taxon.Id,
                            _taxonRevision.Id);
                    if (swedishHistoryRevisionSpeciesFact != null)
                    {
                        if (swedishHistoryRevisionSpeciesFact.StatusId.HasValue)
                        {
                            SpeciesFactModelManager speciesFactModel = new SpeciesFactModelManager(taxon, _userContext);
                            TaxonModelManager.UpdateOldSpeciesFactModelWithDyntaxaRevisionSpeciesFactValues(_userContext, speciesFactModel.SwedishHistorySpeciesFact, swedishHistoryRevisionSpeciesFact);
                            model.SwedishHistory     = speciesFactModel.SwedishHistorySpeciesFact.GetStatusOriginalLabel();
                            model.SwedishHistoryFact = speciesFactModel.SwedishHistorySpeciesFact;
                        }
                        else // swedish history is deleted in this revision
                        {
                            model.SwedishHistory     = null;
                            model.SwedishHistoryFact = null;
                        }
                    }
                }
            }
            catch (Exception)
            {
                // the taxon did not exist in Artfakta
            }

            const int noRedListValue = 6;

            if (!string.IsNullOrEmpty(model.RedListInfo) && redListValue.GetValueOrDefault(0) < noRedListValue)
            {
                var    linkManager = new LinkManager();
                string url         = linkManager.GetUrlToRedlist(taxon.Id.ToString());
                if (url != "")
                {
                    var item = new LinkItem(
                        LinkType.Url,
                        LinkQuality.ApprovedByExpert,
                        Resources.DyntaxaResource.LinkToSwedishRedlistLabel,
                        url);
                    model.RedListLink = item;
                }
            }

            return(model);
        }
        public void GetDyntaxaRevisionSpeciesFact_WhenRowIsCreatedAndLaterChanged_ThenLastChangedRowReturned()
        {
            DyntaxaRevisionSpeciesFact dyntaxaRevisionSpeciesFact1, dyntaxaRevisionSpeciesFact2, currentDyntaxaRevisionSpeciesFact;
            TaxonRevisionEvent         revisionEvent1, revisionEvent2;
            Int32 revisionId = 1;

            //-------------------------------------------------------------------
            // Create first dyntaxa revision species fact and revision event.
            dyntaxaRevisionSpeciesFact1             = GetReferenceDyntaxaRevisionSpeciesFact((Int32)TaxonId.Bear);
            dyntaxaRevisionSpeciesFact1.FactorId    = (Int32)FactorId.SwedishHistory;
            dyntaxaRevisionSpeciesFact1.RevisionId  = revisionId;
            dyntaxaRevisionSpeciesFact1.IsPublished = false;
            dyntaxaRevisionSpeciesFact1.StatusId    = 400;
            dyntaxaRevisionSpeciesFact1.ChangedInRevisionEventId = null;

            revisionEvent1 = new TaxonRevisionEvent()
            {
                CreatedBy   = 2,
                CreatedDate = DateTime.Now,
                Type        = new TaxonRevisionEventType()
                {
                    Description = "", Id = 1, Identifier = ""
                },
                RevisionId   = revisionId,
                AffectedTaxa = "Bear",
                OldValue     = "StatusId=Unknown",
                NewValue     = "StatusId=400"
            };

            IUserContext userContext = GetRevisionUserContext();
            DyntaxaInternalTaxonServiceManager manager = new DyntaxaInternalTaxonServiceManager();

            using (ITransaction transaction = userContext.StartTransaction())
            {
                revisionEvent1 = manager.CreateCompleteRevisionEvent(userContext, revisionEvent1);

                dyntaxaRevisionSpeciesFact1.RevisionEventId = revisionEvent1.Id;
                dyntaxaRevisionSpeciesFact1 = manager.CreateDyntaxaRevisionSpeciesFact(userContext,
                                                                                       dyntaxaRevisionSpeciesFact1);
                currentDyntaxaRevisionSpeciesFact = manager.GetDyntaxaRevisionSpeciesFact(
                    userContext, (Int32)FactorId.SwedishHistory, (Int32)TaxonId.Bear, revisionId);

                //Assert first Insert
                Assert.AreEqual(revisionEvent1.Id, dyntaxaRevisionSpeciesFact1.RevisionEventId);
                Assert.IsFalse(currentDyntaxaRevisionSpeciesFact.ChangedInRevisionEventId.HasValue);
                Assert.AreEqual(400, currentDyntaxaRevisionSpeciesFact.StatusId);
                Assert.AreEqual(dyntaxaRevisionSpeciesFact1.StatusId, currentDyntaxaRevisionSpeciesFact.StatusId);

                //---------------------------------------------------------------------
                // Create second dyntaxa revision species fact and revision event.
                dyntaxaRevisionSpeciesFact2             = GetReferenceDyntaxaRevisionSpeciesFact((Int32)TaxonId.Bear);
                dyntaxaRevisionSpeciesFact2.FactorId    = (Int32)FactorId.SwedishHistory;
                dyntaxaRevisionSpeciesFact2.RevisionId  = revisionId;
                dyntaxaRevisionSpeciesFact2.IsPublished = false;
                dyntaxaRevisionSpeciesFact2.StatusId    = 450; // changed from 400 to 450.

                revisionEvent2 = new TaxonRevisionEvent()
                {
                    CreatedBy   = 3, //Changed
                    CreatedDate = DateTime.Now,
                    Type        = new TaxonRevisionEventType()
                    {
                        Description = "", Id = 1, Identifier = ""
                    },
                    RevisionId   = revisionId,
                    AffectedTaxa = "Bear",
                    OldValue     = "StatusId=400", //Changed
                    NewValue     = "StatusId=450"  //Changed
                };
                revisionEvent2 = manager.CreateCompleteRevisionEvent(userContext, revisionEvent2);
                dyntaxaRevisionSpeciesFact2.RevisionEventId = revisionEvent2.Id;
                dyntaxaRevisionSpeciesFact2 = manager.CreateDyntaxaRevisionSpeciesFact(userContext,
                                                                                       dyntaxaRevisionSpeciesFact2);
                currentDyntaxaRevisionSpeciesFact = manager.GetDyntaxaRevisionSpeciesFact(
                    userContext, (Int32)FactorId.SwedishHistory, (Int32)TaxonId.Bear, revisionId);

                // Check values.
                Assert.AreEqual(450, currentDyntaxaRevisionSpeciesFact.StatusId);
                Assert.AreEqual(revisionEvent2.Id, currentDyntaxaRevisionSpeciesFact.RevisionEventId);
                Assert.IsFalse(currentDyntaxaRevisionSpeciesFact.ChangedInRevisionEventId.HasValue);
                // Check latest change is returned.
                Assert.AreEqual(dyntaxaRevisionSpeciesFact2.Id, currentDyntaxaRevisionSpeciesFact.Id);
                Assert.AreNotEqual(dyntaxaRevisionSpeciesFact1.Id, currentDyntaxaRevisionSpeciesFact.Id);
            }
        }