C# BusinessContext.GetTargetPrimaryKeyId方法代码示例

        /// <summary>
        /// Closes the assignment.
        /// </summary>
        /// <param name="context">The context.</param>
        protected virtual void CloseAssignment(BusinessContext context)
        {
            CloseAssignmentRequest request = (CloseAssignmentRequest)context.Request;

            // Load Assignment
            MetaObject metaObject = MetaObjectActivator.CreateInstance(AssignmentEntity.ClassName, context.GetTargetPrimaryKeyId().Value);

            if (((int)metaObject[AssignmentEntity.FieldState]) != (int)AssignmentState.Active)
                throw new InvalidOperationException();

            DateTime dateTimeNow = DataContext.Current.CurrentUserTimeZone.ToLocalTime(DateTime.UtcNow);

            // Update Meta Object Fields
            metaObject[AssignmentEntity.FieldClosedBy] = (int)DataContext.Current.CurrentUserId;
            metaObject[AssignmentEntity.FieldState] = (int)AssignmentState.Closed;
            metaObject[AssignmentEntity.FieldExecutionResult] = request.ExecutionResult;
            metaObject[AssignmentEntity.FieldComment] = request.Comment;
            metaObject[AssignmentEntity.FieldActualFinishDate] = dateTimeNow;

            // Save Meta Object
            metaObject.Save();

            if (metaObject[AssignmentEntity.FieldWorkflowInstanceId]!=null)
            {
                // Run Workflow
                AssignmentEntity entity = (AssignmentEntity)BusinessManager.Load(AssignmentEntity.ClassName, context.GetTargetPrimaryKeyId().Value);
                RunWorkflow(entity);
            }

            context.SetResponse(new Response());
        }

 public void Execute(BusinessContext context)
 {
     _log.Debug("Execute (IPlugin) for {0}. Metaclass: {1}. PrimaryKey: {2}. Plugin Stage: {3}",
         context.GetMethod(),
         context.GetTargetMetaClassName(),
         context.GetTargetPrimaryKeyId().HasValue ? context.GetTargetPrimaryKeyId().Value.ToString() : "null",
         context.PluginStage);
 }

        protected override void PreDeleteInsideTransaction(BusinessContext context)
        {
            base.PreDeleteInsideTransaction(context);

            // Remove SecureRole From Principal
            DirectoryManager.DeletePrincipal(context.GetTargetPrimaryKeyId().Value);
        }

        /// <summary>
        /// Resets the delivery attempts.
        /// </summary>
        /// <param name="context">The context.</param>
        protected virtual void ResetDeliveryAttempts(BusinessContext context)
        {
            MetaObject metaObject = MetaObjectActivator.CreateInstance(context.GetTargetMetaClassName(), context.GetTargetPrimaryKeyId().Value);

            metaObject[OutgoingMessageQueueEntity.FieldDeliveryAttempts] = 0;

            metaObject.Save();
        }

        /// <summary>
        /// Deletes the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        protected override void Delete(BusinessContext context)
        {
            // OZ: Comment base logic and call custom business logic ListManager.DeleteList
            //base.Delete(context);

            ListManager.DeleteList((int)context.GetTargetPrimaryKeyId().Value);

            context.SetResponse(new Response());
        }

        /// <summary>
        /// Executes the specified contex.
        /// </summary>
        /// <param name="context">The context.</param>
        protected virtual void Execute(BusinessContext context)
        {
            if ((context.GetMethod() == RequestMethod.Update ||
                context.GetMethod() == RequestMethod.Create) &&
                context.GetTargetPrimaryKeyId().HasValue)
            {
                if (context.Request.Target.Properties.GetValue<bool>(AssignmentEntity.FieldAutoComplete, false))
                {
                    decimal planWork = context.Request.Target.Properties.GetValue<decimal>(AssignmentEntity.FieldPlanWork, decimal.MaxValue);
                    decimal actualWork = context.Request.Target.Properties.GetValue<decimal>(AssignmentEntity.FieldActualWork, decimal.MinValue);

                    if (planWork == actualWork)
                    {
                        // Invoke Auto Complete
                        BusinessManager.Execute(new CloseAssignmentRequest(context.GetTargetPrimaryKeyId().Value, (int)AssignmentExecutionResult.Accepted));
                    }
                }
            }
        }

        /// <summary>
        /// Executes the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        public void Execute(BusinessContext context)
        {
            switch (context.GetMethod())
            {
                case RequestMethod.Load:
                    if (context.GetTargetPrimaryKeyId().HasValue)
                    {
                        EntityObject item = LoadEntityObject(context.GetTargetMetaClassName(), context.GetTargetPrimaryKeyId().Value);

                        if (item != null)
                        {
                            LoadResponse response = new LoadResponse(item);

                            context.SetResponse(response);
                        }
                    }
                    break;
                case RequestMethod.List:
                    {
                        // Filters Not Implemented
                        ListResponse response = context.Response as ListResponse;

                        if (response != null)
                        {
                            EntityObject[] items = LoadEntityObjects(context.GetTargetMetaClassName(), ((ListRequest)context.Request).Filters);

                            if (items.Length > 0)
                            {
                                List<EntityObject> newArray = new List<EntityObject>(response.EntityObjects.Length + items.Length);

                                newArray.AddRange(response.EntityObjects);
                                newArray.AddRange(items);

                                // TODO: Sorting Not Implemented

                                response.EntityObjects = newArray.ToArray();
                            }
                        }
                    }
                    break;
            }
        }

        /// <summary>
        /// Pres the delete inside transaction.
        /// </summary>
        /// <param name="context">The context.</param>
        protected override void PreDeleteInsideTransaction(BusinessContext context)
        {
            base.PreDeleteInsideTransaction(context);

            #region Remove references from IBN 4.7 objects
            SqlHelper.ExecuteNonQuery(SqlContext.Current, System.Data.CommandType.StoredProcedure,
                "bus_cls_ListObject_Delete",
                SqlHelper.SqlParameter("@ClassName", SqlDbType.NVarChar, 250, context.GetTargetMetaClassName()),
                SqlHelper.SqlParameter("@ObjectId", SqlDbType.VarChar, 36, context.GetTargetPrimaryKeyId().Value.ToString()));
            #endregion
        }

        /// <summary>
        /// Executes the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        void IPlugin.Execute(BusinessContext context)
        {
            if (context.GetMethod() == RequestMethod.Delete &&
                context.GetTargetPrimaryKeyId().HasValue)
            {
                MetaClass currentMetaClass = DataContext.Current.GetMetaClass(context.GetTargetMetaClassName());

                foreach (MetaField mf in currentMetaClass.FindReferencesTo())
                {
                    if (mf.Owner.IsBridge)
                    {
                        foreach(EntityObject entity in BusinessManager.List(mf.Owner.Name,
                            new FilterElement[] { FilterElement.EqualElement(mf.Name, context.GetTargetPrimaryKeyId().Value) }))
                        {
                            BusinessManager.Delete(entity);
                        }
                    }
                }
            }
        }

        protected override void PostUpdateInsideTransaction(BusinessContext context)
        {
            base.PostUpdateInsideTransaction(context);

            // Update Principal
            if(context.Request.Target.Properties.Contains(DirectoryWorkGroupEntity.FieldName))
            {
                DirectoryManager.UpdatePrincipal(context.GetTargetPrimaryKeyId().Value,
                    (string)context.Request.Target[DirectoryWorkGroupEntity.FieldName]);
            }
        }

 /// <summary>
 /// Executes the specified context.
 /// </summary>
 /// <param name="context">The context.</param>
 public void Execute(BusinessContext context)
 {
     if (context.PluginStage == EventPipeLineStage.PreMainOperationInsideTranasaction)
     {
         switch (context.GetMethod())
         {
             case RequestMethod.Delete:
                 // TODO: Pre Method
                 OnAssignmentDeleting(context.GetTargetPrimaryKeyId().Value);
                 break;
             case AssignmentRequestMethod.AssignUser:
             case RequestMethod.Update:
             case AssignmentRequestMethod.Activate:
             case AssignmentRequestMethod.Close:
             case AssignmentRequestMethod.Resume:
             case AssignmentRequestMethod.Suspend:
                 // Save Old AssignmentEntity
                 SaveOldAssignmentEntity(context, (AssignmentEntity)BusinessManager.Load(AssignmentEntity.ClassName, context.GetTargetPrimaryKeyId().Value));
                 break;
         }
     }
     else if (context.PluginStage == EventPipeLineStage.PostMainOperationInsideTranasaction)
     {
         switch (context.GetMethod())
         {
             case RequestMethod.Create:
                 OnAssignmentCreated(((CreateResponse)context.Response).PrimaryKeyId);
                 break;
             case AssignmentRequestMethod.AssignUser:
             case RequestMethod.Update:
             case AssignmentRequestMethod.Activate:
             case AssignmentRequestMethod.Close:
             case AssignmentRequestMethod.Resume:
             case AssignmentRequestMethod.Suspend:
                 // TODO: Pre Method
                 OnAssignmentUpdated(LoadOldAssignmentEntity(context), (AssignmentEntity)BusinessManager.Load(AssignmentEntity.ClassName, context.GetTargetPrimaryKeyId().Value));
                 break;
         }
     }
 }

        /// <summary>
        /// Executes the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        public virtual void Execute(BusinessContext context)
        {
            WorkflowInstanceEntity entityObject = (WorkflowInstanceEntity)BusinessManager.Load(context.GetTargetMetaClassName(), context.GetTargetPrimaryKeyId().Value);

            if (entityObject.OwnerDocumentId.HasValue)
            {
                Document.SetReadOnly(
                    entityObject.OwnerDocumentId.Value,
                    false);
            }

            // TODO: Add New Owner Here
        }

        /// <summary>
        /// Executes the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        public virtual void Execute(BusinessContext context)
        {
            WorkflowInstanceEntity entityObject = (WorkflowInstanceEntity)BusinessManager.Load(context.GetTargetMetaClassName(), context.GetTargetPrimaryKeyId().Value);

            if (entityObject.State == (int)BusinessProcessState.Closed &&
                entityObject.ExecutionResult == (int)BusinessProcessExecutionResult.Accepted)
            {
                if (entityObject.OwnerDocumentId.HasValue)
                {
                    Document.SetReadOnly(
                        entityObject.OwnerDocumentId.Value,
                        WorkflowParameters.GetOwnerReadOnly(entityObject));
                }

                // TODO: Add New Owner Here
            }
        }

        /// <summary>
        /// Pres the delete inside transaction.
        /// </summary>
        /// <param name="context">The context.</param>
        protected override void PreDeleteInsideTransaction(BusinessContext context)
        {
            base.PreDeleteInsideTransaction(context);

            CustomizationProfileEntity entity = (CustomizationProfileEntity)BusinessManager.Load(CustomizationProfileEntity.ClassName, context.GetTargetPrimaryKeyId().Value);

            int profileId = (int)entity.PrimaryKeyId.Value;

            // Reset users to default profile
            if (profileId != -1)
            {
                EntityObject[] list = BusinessManager.List(CustomizationProfileUserEntity.ClassName,
                    new FilterElementCollection(FilterElement.EqualElement(CustomizationProfileUserEntity.FieldProfileId, profileId)).ToArray());
                foreach (CustomizationProfileUserEntity userProfile in list)
                {
                    string userId = userProfile.PrincipalId.ToString();
                    BusinessManager.Delete(userProfile);
                    DataCache.RemoveByUser(userId);
                }
            }

            // Delete profile info from cls_CustomizationItem
            EntityObject[] customizationItems = BusinessManager.List(CustomizationItemEntity.ClassName,
                new FilterElementCollection(FilterElement.EqualElement(CustomizationItemEntity.FieldProfileId, profileId)).ToArray());
            foreach (EntityObject obj in customizationItems)
                BusinessManager.Delete(obj);

            // Delete profile info from cls_CustomPage
            EntityObject[] customPageItems = BusinessManager.List(CustomPageEntity.ClassName,
                new FilterElementCollection(FilterElement.EqualElement(CustomPageEntity.FieldProfileId, profileId)).ToArray());
            foreach (EntityObject obj in customizationItems)
                BusinessManager.Delete(obj);

            // Delete history
            SqlHelper.ExecuteNonQuery(SqlContext.Current,
                System.Data.CommandType.StoredProcedure,
                "HistoryEntityDelete",
                SqlHelper.SqlParameter("@ClassName", SqlDbType.NVarChar, 250, CustomizationProfileEntity.ClassName),
                SqlHelper.SqlParameter("@ObjectId", SqlDbType.VarChar, 36, profileId.ToString()));
        }

        /// <summary>
        /// Deletes sticked items if the method is "delete" or assignment state is not active
        /// </summary>
        /// <param name="context">The context.</param>
        public void Execute(BusinessContext context)
        {
            if (context.GetMethod() == RequestMethod.Load ||
                context.GetMethod() == RequestMethod.List)
                return;

            PrimaryKeyId? pkId = context.GetTargetPrimaryKeyId();
            if (pkId.HasValue)
            {
                AssignmentEntity entity = (AssignmentEntity)BusinessManager.Load(AssignmentEntity.ClassName, pkId.Value);

                if (entity.OwnerDocumentId.HasValue)
                {
                    if (context.GetMethod() == RequestMethod.Delete ||
                        entity.State != (int)AssignmentState.Active)
                    {
                        if (entity.UserId.HasValue)
                        {
                            Calendar.DeleteStickedObject(entity.UserId.Value, entity.OwnerDocumentId.Value, (int)ObjectTypes.Document, (Guid)pkId.Value);
                        }
                    }
                }
            }
        }