private void reArrangeResCollaborationsAfterMove(ICollection <DrcCard> targetVersionCards, DrcCardResponsibility resCollaboration)
        {
            var collaborationCard = _documentTransferUnitOfWork.DrcCardRepository.GetById(resCollaboration.DrcCardId);

            foreach (var drcCard in targetVersionCards.ToList())
            {
                if (drcCard.MainCardId != null && collaborationCard.MainCardId != null && (collaborationCard.MainCardId == (int)drcCard.MainCardId))
                {
                    DrcCardResponsibility newResponsibility = new DrcCardResponsibility();
                    newResponsibility.Responsibility   = resCollaboration.Responsibility;
                    newResponsibility.ResponsibilityId = resCollaboration.ResponsibilityId;
                    _documentTransferUnitOfWork.DrcCardResponsibilityRepository.Remove(resCollaboration);
                    newResponsibility.IsRelationCollaboration = true;
                    newResponsibility.DrcCard = drcCard;
                    _documentTransferUnitOfWork.DrcCardResponsibilityRepository.Add(newResponsibility);
                }
                else if (drcCard.MainCardId != null && collaborationCard.MainCardId == null && (collaborationCard.Id == (int)drcCard.MainCardId))
                {
                    DrcCardResponsibility newResponsibility = new DrcCardResponsibility
                    {
                        Responsibility   = resCollaboration.Responsibility,
                        ResponsibilityId = resCollaboration.ResponsibilityId
                    };
                    _documentTransferUnitOfWork.DrcCardResponsibilityRepository.Remove(resCollaboration);
                    newResponsibility.IsRelationCollaboration = true;
                    newResponsibility.DrcCard = drcCard;
                    _documentTransferUnitOfWork.DrcCardResponsibilityRepository.Add(newResponsibility);
                }
                else if (drcCard.MainCardId != null && (collaborationCard.Id == (int)drcCard.MainCardId))
                {
                    DrcCardResponsibility newResponsibility = new DrcCardResponsibility
                    {
                        Responsibility   = resCollaboration.Responsibility,
                        ResponsibilityId = resCollaboration.ResponsibilityId
                    };
                    _documentTransferUnitOfWork.DrcCardResponsibilityRepository.Remove(resCollaboration);
                    newResponsibility.IsRelationCollaboration = true;
                    newResponsibility.DrcCard = drcCard;
                    _documentTransferUnitOfWork.DrcCardResponsibilityRepository.Add(newResponsibility);
                }
                else if (collaborationCard.MainCardId != null && collaborationCard.MainCardId == drcCard.Id)
                {
                    DrcCardResponsibility newResponsibility = new DrcCardResponsibility
                    {
                        Responsibility   = resCollaboration.Responsibility,
                        ResponsibilityId = resCollaboration.ResponsibilityId
                    };
                    _documentTransferUnitOfWork.DrcCardResponsibilityRepository.Remove(resCollaboration);
                    newResponsibility.IsRelationCollaboration = true;
                    newResponsibility.DrcCard = drcCard;
                    _documentTransferUnitOfWork.DrcCardResponsibilityRepository.Add(newResponsibility);
                }
            }
        }
        public void Add(string values)
        {
            var newResponsibilityModel = new ResponsibilityBusinessModel();

            JsonConvert.PopulateObject(values, newResponsibilityModel);
            if (newResponsibilityModel.ResponsibilityDefinition != null)
            {
                var newResponsibility = new Responsibility();
                newResponsibility.ResponsibilityDefinition = newResponsibilityModel.ResponsibilityDefinition;
                newResponsibility.IsMandatory   = newResponsibilityModel.IsMandatory;
                newResponsibility.Title         = newResponsibilityModel.Title;
                newResponsibility.PriorityOrder = newResponsibilityModel.PriorityOrder;
                _drcUnitOfWork.ResponsibilityRepository.Add(newResponsibility);


                var drcCardResponsibility = new DrcCardResponsibility();
                drcCardResponsibility.Responsibility = newResponsibility;
                drcCardResponsibility.DrcCard        = _drcUnitOfWork.DrcCardRepository.GetById(newResponsibilityModel.DrcCardId);
                _drcUnitOfWork.DrcCardResponsibilityRepository.Add(drcCardResponsibility);

                DrcCardResponsibility drcCardResponsibilityWithShadow;
                if (newResponsibilityModel.ShadowCardIds != null)
                {
                    foreach (var collaborationCardId in newResponsibilityModel.ShadowCardIds)
                    {
                        drcCardResponsibilityWithShadow = new DrcCardResponsibility();
                        drcCardResponsibilityWithShadow.Responsibility          = newResponsibility;
                        drcCardResponsibilityWithShadow.DrcCard                 = _drcUnitOfWork.DrcCardRepository.GetById(collaborationCardId);
                        drcCardResponsibilityWithShadow.IsRelationCollaboration = true;
                        _drcUnitOfWork.DrcCardResponsibilityRepository.Add(drcCardResponsibilityWithShadow);
                        _drcUnitOfWork.Complete();
                    }
                }

                _drcUnitOfWork.Complete();
            }
            else
            {
                //do nothing
            }
        }
        public void Update(int id, string values)
        {
            Responsibility responsibility = _drcUnitOfWork.ResponsibilityRepository.GetById(id);
            ResponsibilityBusinessModel responsibilityBusinessModel = _mapper.Map <ResponsibilityBusinessModel>(responsibility);

            _drcUnitOfWork.ResponsibilityRepository.Remove(responsibility);
            var responsibilityCollaborations = _drcUnitOfWork.DrcCardResponsibilityRepository.GetResponsibilityCollaborationsByResponsibilityId(id);

            int[] shadowIds = new int[responsibilityCollaborations.Count];
            int   i         = 0;

            foreach (var responsibilityCollaboration in responsibilityCollaborations)
            {
                shadowIds[i] = responsibilityCollaboration.DrcCardId;
                _drcUnitOfWork.DrcCardResponsibilityRepository.Remove(responsibilityCollaboration);
                i++;
            }
            responsibilityBusinessModel.ShadowCardIds = shadowIds;
            JsonConvert.PopulateObject(values, responsibilityBusinessModel);

            var newResponsibility = _mapper.Map <Responsibility>(responsibilityBusinessModel);

            if (responsibilityBusinessModel.ShadowCardIds != null)
            {
                DrcCardResponsibility resCollaboration;
                foreach (var drcresponsibilityCollaborationCard in responsibilityBusinessModel.ShadowCardIds)
                {
                    resCollaboration                         = new DrcCardResponsibility();
                    resCollaboration.DrcCard                 = _drcUnitOfWork.DrcCardRepository.GetById(drcresponsibilityCollaborationCard);
                    resCollaboration.Responsibility          = newResponsibility;
                    resCollaboration.IsRelationCollaboration = true;
                    newResponsibility.DrcCardResponsibilities.Add(resCollaboration);
                }
            }
            _drcUnitOfWork.ResponsibilityRepository.Add(newResponsibility);
            _drcUnitOfWork.Complete();
        }
Esempio n. 4
0
        public void CloneSourceVersionToNewVersion(SubdomainVersion subdomainVersion)
        {
            var sourceId = (int)subdomainVersion.SourceVersionId;

            var sourceVersionCards = _drcUnitOfWork.DrcCardRepository.getAllCardsBySubdomainVersion(sourceId);


            IList <SourceNewDrcCardMap> sourceNewDrcCardMaps = new List <SourceNewDrcCardMap>();

            foreach (var sourceVersionCard in sourceVersionCards)
            {
                SourceNewDrcCardMap sourceNewDrcCardMap = new SourceNewDrcCardMap();
                sourceNewDrcCardMap.SourceCardId = sourceVersionCard.Id;

                DrcCard newDrcCard = new DrcCard();
                newDrcCard    = sourceVersionCard;
                newDrcCard.Id = 0;
                newDrcCard.SubdomainVersionId = 0;
                newDrcCard.SubdomainVersion   = subdomainVersion;
                _drcUnitOfWork.DrcCardRepository.Add(newDrcCard);
                _drcUnitOfWork.Complete();
                sourceNewDrcCardMap.NewCardId = newDrcCard.Id;
                sourceNewDrcCardMaps.Add(sourceNewDrcCardMap);
            }

            foreach (var sourceNewDrcCardMap in sourceNewDrcCardMaps)
            {
                var newDrcCard = _drcUnitOfWork.DrcCardRepository.GetById(sourceNewDrcCardMap.NewCardId);
                var sourceCardResponsibilities =
                    _drcUnitOfWork.DrcCardResponsibilityRepository.GetDrcCardResponsibilitiesByDrcCardId(
                        sourceNewDrcCardMap.SourceCardId);

                foreach (var sourceDrcCardResponsibility in sourceCardResponsibilities)
                {
                    Responsibility newResponsibility = new Responsibility();
                    newResponsibility =
                        _drcUnitOfWork.ResponsibilityRepository.GetByIdWithoutTracking(sourceDrcCardResponsibility
                                                                                       .ResponsibilityId);
                    var sourceResponsibilityCollaborations = _drcUnitOfWork.DrcCardResponsibilityRepository.GetResponsibilityCollaborationsByResponsibilityId(newResponsibility.Id);
                    newResponsibility.Id = 0;
                    _drcUnitOfWork.ResponsibilityRepository.Add(newResponsibility);

                    DrcCardResponsibility newDrcCardResponsibility = new DrcCardResponsibility();
                    newDrcCardResponsibility.DrcCard                 = newDrcCard;
                    newDrcCardResponsibility.Responsibility          = newResponsibility;
                    newDrcCardResponsibility.IsRelationCollaboration = false;
                    _drcUnitOfWork.DrcCardResponsibilityRepository.Add(newDrcCardResponsibility);

                    foreach (var sourceResponsibilityCollaboration in sourceResponsibilityCollaborations)
                    {
                        int newDrcCardId = sourceNewDrcCardMaps
                                           .Where(c => c.SourceCardId == sourceResponsibilityCollaboration.DrcCardId)
                                           .Select(c => c.NewCardId).Single();
                        DrcCardResponsibility newResponsibilityCollaboration = new DrcCardResponsibility();
                        newResponsibilityCollaboration.DrcCardId               = newDrcCardId;
                        newResponsibilityCollaboration.Responsibility          = newResponsibility;
                        newResponsibilityCollaboration.IsRelationCollaboration =
                            sourceResponsibilityCollaboration.IsRelationCollaboration;
                        _drcUnitOfWork.DrcCardResponsibilityRepository.Add(newResponsibilityCollaboration);
                        _drcUnitOfWork.Complete();
                    }
                    _drcUnitOfWork.Complete();
                }

                var sourceCardFields = _drcUnitOfWork.DrcCardFieldRepository
                                       .GetDrcCardFieldsByDrcCardId(sourceNewDrcCardMap.SourceCardId);

                foreach (var sourceCardField in sourceCardFields)
                {
                    Field newField = new Field();
                    newField = _drcUnitOfWork.FieldRepository.GetByIdWithoutTracking(sourceCardField.FieldId);
                    var sourceFieldCollaboration =
                        _drcUnitOfWork.DrcCardFieldRepository.GetFieldCollaborationByFieldId(newField.Id);
                    newField.Id = 0;
                    _drcUnitOfWork.FieldRepository.Add(newField);

                    DrcCardField newDrcCardField = new DrcCardField();
                    newDrcCardField.DrcCard = newDrcCard;
                    newDrcCardField.Field   = newField;
                    newDrcCardField.IsRelationCollaboration = false;
                    _drcUnitOfWork.DrcCardFieldRepository.Add(newDrcCardField);

                    if (sourceFieldCollaboration != null)
                    {
                        int newCollaborationDrcCardId = sourceNewDrcCardMaps
                                                        .Where(c => c.SourceCardId == sourceFieldCollaboration.DrcCardId)
                                                        .Select(c => c.NewCardId).Single();

                        DrcCardField newDrcCardFieldCollaboration = new DrcCardField();
                        newDrcCardFieldCollaboration.DrcCardId = newCollaborationDrcCardId;
                        newDrcCardFieldCollaboration.Field     = newField;
                        newDrcCardFieldCollaboration.IsRelationCollaboration = true;
                        _drcUnitOfWork.DrcCardFieldRepository.Add(newDrcCardFieldCollaboration);
                        _drcUnitOfWork.Complete();
                    }
                    _drcUnitOfWork.Complete();
                }

                var sourceCardAuthorizations = _drcUnitOfWork.AuthorizationRepository.GetAuthorizationsByDrcCardId(sourceNewDrcCardMap.SourceCardId);

                foreach (var sourceCardAuthorization in sourceCardAuthorizations)
                {
                    Authorization newAuthorization = new Authorization();
                    newAuthorization = _drcUnitOfWork.AuthorizationRepository.GetByIdWithoutTracking(sourceCardAuthorization.Id);
                    var oldAuthorizationRoles = _drcUnitOfWork.AuthorizationRoleRepository.GetAuthorizationRolesByAuthorizationId(newAuthorization.Id);
                    newAuthorization.Id        = 0;
                    newAuthorization.DrcCardId = 0;
                    newAuthorization.DrcCard   = newDrcCard;
                    _drcUnitOfWork.AuthorizationRepository.Add(newAuthorization);

                    foreach (var oldAuthorizationRole in oldAuthorizationRoles)
                    {
                        AuthorizationRole authorizationRole = new AuthorizationRole();
                        authorizationRole.AuthorizationId = newAuthorization.Id;
                        authorizationRole.RoleId          = oldAuthorizationRole.RoleId;
                        _drcUnitOfWork.AuthorizationRoleRepository.Add(authorizationRole);
                        _drcUnitOfWork.Complete();
                    }
                }
                _drcUnitOfWork.Complete();
            }
        }