public ActionResult Create()
        {
            var model = new RemoteTextFolderMapping();

            model.Enabled = true;
            return(View(model));
        }
 public virtual void Delete(string[] uuids)
 {
     foreach (string uuid in uuids)
     {
         var model = new RemoteTextFolderMapping(uuid).AsActual();
         this._remotePublishingMappingProvider.Remove(model);
     }
 }
        protected virtual void PublishTextContent(ref RemotePublishingQueue queueItem, PublishingAction action, out RemoteEndpointSetting remoteEndpoint)
        {
            remoteEndpoint = null;
            var mapping = new RemoteTextFolderMapping(queueItem.Site, queueItem.TextFolderMapping).AsActual();

            if (mapping == null)
            {
                NoSuchPublishingMapping(ref queueItem);
                return;
            }
            remoteEndpoint = new RemoteEndpointSetting(queueItem.Site, mapping.RemoteEndpoint).AsActual();

            if (remoteEndpoint == null)
            {
                NoSuchEndpoint(ref queueItem, mapping.RemoteEndpoint);
                return;
            }
            var contentIntegrateId = new ContentIntegrateId(queueItem.ObjectUUID);
            var repository         = new Repository(contentIntegrateId.Repository).AsActual();

            if (repository != null)
            {
                var textFolder = new TextFolder(repository, contentIntegrateId.FolderName).AsActual();
                if (textFolder != null)
                {
                    var contentUUID = contentIntegrateId.ContentUUID;

                    var content = textFolder.CreateQuery().WhereEquals("UUID", contentUUID).FirstOrDefault();
                    if (content != null)
                    {
                        var cmisService = _cmisSession.OpenSession(remoteEndpoint.CmisService, remoteEndpoint.CmisUserName, remoteEndpoint.CmisPassword);

                        switch (action)
                        {
                        case PublishingAction.Publish:
                            content.Published = true;
                            var categories = _textContentProvider.QueryCategories(content);
                            cmisService.AddTextContent(remoteEndpoint.RemoteRepositoryId, mapping.RemoteFolderId, content, categories);
                            queueItem.UtcProcessedPublishTime = DateTime.UtcNow;
                            break;

                        case PublishingAction.Unbpulish:
                            cmisService.DeleteTextContent(remoteEndpoint.RemoteRepositoryId, mapping.RemoteFolderId, content.UUID);
                            queueItem.UtcProcessedUnpublishTime = DateTime.UtcNow;
                            break;

                        case PublishingAction.None:
                        default:
                            break;
                        }
                        return;
                    }
                }
            }

            NoSuchObjectMessage(ref queueItem);
        }
 public virtual void Delete(Site site, string[] uuids)
 {
     foreach (string uuid in uuids)
     {
         var model = new RemoteTextFolderMapping(site, uuid).AsActual();
         if (model != null)
         {
             this._remotePublishingMappingProvider.Remove(model);
         }
     }
 }
        public ActionResult Create(RemoteTextFolderMapping mapping, string @return)
        {
            var resultEntry = new JsonResultData(ModelState);

            if (ModelState.IsValid)
            {
                resultEntry.RunWithTry((data) =>
                {
                    _manager.Add(mapping);
                    data.RedirectUrl = @return;
                });
            }
            return(Json(resultEntry));
        }
        public ActionResult Edit(RemoteTextFolderMapping mapping, string @return)
        {
            var resultEntry = new JsonResultData(ModelState);

            if (ModelState.IsValid)
            {
                resultEntry.RunWithTry((data) =>
                {
                    var oldModel = _manager.Get(mapping.UUID);
                    _manager.Update(mapping, oldModel);
                    resultEntry.RedirectUrl = @return;
                });
            }
            return(Json(resultEntry));
        }
        private void RemotePublish(ref PublishingQueue queueItem, PublishingAction action)
        {
            var site = queueItem.Site;

            if (site != null)
            {
                switch (queueItem.PublishingObject)
                {
                case PublishingObject.Page:
                    if (queueItem.RemoteEndpoints != null)
                    {
                        var page = new Page(site, queueItem.ObjectUUID).AsActual();
                        if (page != null)
                        {
                            foreach (var remote in queueItem.RemoteEndpoints)
                            {
                                var outgoingQueue = new OutgoingQueue(queueItem.Site, Kooboo.UniqueIdGenerator.GetInstance().GetBase32UniqueId(10));
                                outgoingQueue.PublishingObject = queueItem.PublishingObject;
                                outgoingQueue.ObjectUUID       = queueItem.ObjectUUID;
                                outgoingQueue.RemoteEndpoint   = remote;
                                outgoingQueue.UtcCreationDate  = DateTime.UtcNow;
                                outgoingQueue.Status           = QueueStatus.Pending;
                                outgoingQueue.RetryTimes       = 0;
                                outgoingQueue.Action           = action;
                                outgoingQueue.PublishDraft     = queueItem.PublishDraft;
                                _outgoingQueueProvider.Add(outgoingQueue);
                            }
                        }
                        else
                        {
                            NoSuchObjectMessage(ref queueItem);
                        }
                    }
                    NoAnyEndPoint(ref queueItem);
                    break;

                case PublishingObject.TextContent:
                    if (queueItem.PublishingMappings != null)
                    {
                        var contentIntegrateId = new ContentIntegrateId(queueItem.ObjectUUID);
                        var repository         = new Repository(contentIntegrateId.Repository).AsActual();;
                        if (repository != null)
                        {
                            var textFolder = new TextFolder(repository, contentIntegrateId.FolderName).AsActual();
                            if (textFolder != null)
                            {
                                var contentUUID = contentIntegrateId.ContentUUID;

                                foreach (var mappingName in queueItem.PublishingMappings)
                                {
                                    var mapping = new RemoteTextFolderMapping();    //todo:AsActual
                                    if (mapping != null)
                                    {
                                        var outgoingQueue = new OutgoingQueue(queueItem.Site, Kooboo.UniqueIdGenerator.GetInstance().GetBase32UniqueId(10));
                                        outgoingQueue.PublishingObject = queueItem.PublishingObject;
                                        outgoingQueue.ObjectUUID       = queueItem.ObjectUUID;
                                        outgoingQueue.RemoteEndpoint   = mapping.RemoteEndpoint;
                                        outgoingQueue.RemoteFolderId   = mapping.RemoteFolderId;
                                        outgoingQueue.UtcCreationDate  = DateTime.UtcNow;
                                        outgoingQueue.Status           = QueueStatus.Pending;
                                        outgoingQueue.RetryTimes       = 0;
                                        outgoingQueue.Action           = action;
                                        outgoingQueue.PublishDraft     = queueItem.PublishDraft;
                                        _outgoingQueueProvider.Add(outgoingQueue);
                                    }
                                }
                            }
                            else
                            {
                                NoSuchObjectMessage(ref queueItem);
                            }
                        }
                        else
                        {
                            NoSuchObjectMessage(ref queueItem);
                        }
                    }
                    NoAnyEndPoint(ref queueItem);
                    break;

                default:
                    NoSuchPublishingObject(ref queueItem);
                    break;
                }
            }
        }