support for "make new feed"

Evergreen/Scriptability/Feed+Scriptability.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import RSParser
 import Account
 import Data
 
@@ -27,6 +28,11 @@ class ScriptableFeed: NSObject, UniqueIdScriptingObject, ScriptingObjectContaine
         return (scriptObjectSpecifier)
     }
 
+    @objc(scriptingSpecifierDescriptor)
+    func scriptingSpecifierDescriptor() -> NSScriptObjectSpecifier {
+        return (self.objectSpecifier ?? NSScriptObjectSpecifier() )
+    }
+
     // MARK: --- ScriptingObject protocol ---
 
     var scriptingKey: String {
@@ -47,6 +53,141 @@ class ScriptableFeed: NSObject, UniqueIdScriptingObject, ScriptingObjectContaine
     var scriptingClassDescription: NSScriptClassDescription {
         return self.classDescription as! NSScriptClassDescription
     }
+    
+
+    // MARK: --- Create Element Handlers ---
+
+    class func parsedFeedForURL(_ urlString:String, _ completionHandler: @escaping (_ parsedFeed: ParsedFeed?) -> Void) {
+        guard let url = URL(string: urlString) else {
+            completionHandler(nil)
+            return
+        }
+        InitialFeedDownloader.download(url) { (parsedFeed) in
+            completionHandler(parsedFeed)
+        }
+    }
+    
+    class func urlForNewFeed(arguments:[String:Any]) -> String?  {
+        var url:String?
+        if let withDataParam = arguments["ObjectData"] {
+            if let objectDataDescriptor = withDataParam as? NSAppleEventDescriptor {
+                url = objectDataDescriptor.stringValue
+            }
+        } else if let withPropsParam = arguments["ObjectProperties"] as? [String:Any] {
+            url = withPropsParam["url"] as? String
+        }
+        return url
+    }
+    
+    class func accountAndFolderForNewFeed(appleEvent:NSAppleEventDescriptor?) -> (Account, Folder?) {
+        var account = AccountManager.shared.localAccount
+        var folder:Folder? = nil
+        if let appleEvent = appleEvent {
+            var descriptorToConsider:NSAppleEventDescriptor?
+            if let insertionLocationDescriptor = appleEvent.paramDescriptor(forKeyword:keyAEInsertHere) {
+                 print("insertionLocation : \(insertionLocationDescriptor)")
+                 // insertion location can be a typeObjectSpecifier, e.g.  'in account "Acct"'
+                 // or a typeInsertionLocation, e.g.   'at end of folder "
+                 if (insertionLocationDescriptor.descriptorType == "insl".FourCharCode())  {
+                     descriptorToConsider = insertionLocationDescriptor.forKeyword("kobj".FourCharCode())
+                 } else if ( insertionLocationDescriptor.descriptorType == "obj ".FourCharCode())  {
+                     descriptorToConsider = insertionLocationDescriptor
+                 }
+            } else if let subjectDescriptor = appleEvent.attributeDescriptor(forKeyword:"subj".FourCharCode()) {
+                descriptorToConsider = subjectDescriptor
+            }
+            
+            if let descriptorToConsider = descriptorToConsider {
+                guard let newContainerSpecifier = NSScriptObjectSpecifier(descriptor:descriptorToConsider) else {return (account, folder)}
+                let newContainer = newContainerSpecifier.objectsByEvaluatingSpecifier
+                if let scriptableAccount = newContainer as? ScriptableAccount {
+                    account = scriptableAccount.account
+                } else if let scriptableFolder = newContainer as? ScriptableFolder {
+                    if let folderAccount = scriptableFolder.folder.account {
+                        folder = scriptableFolder.folder
+                        account = folderAccount
+                    }
+                }
+            }
+            print("found account : \(account)")
+            print("found folder : \(folder)")
+        }
+        return (account, folder)
+    }
+    
+    class func handleCreateElement(command:NSCreateCommand) -> Any?  {
+        let appleEventManager = NSAppleEventManager.shared()
+        if let receivers = command.receiversSpecifier  {
+            print("receivers : \(receivers)")
+        }
+        if let evaluatedReceivers = command.evaluatedReceivers  {
+            print("evaluatedReceivers : \(evaluatedReceivers)")
+        }
+        if let evaluatedArguments = command.evaluatedArguments  {
+            print("evaluatedArguments : \(evaluatedArguments)")
+        }
+        if let directObject = command.directParameter  {
+            print("directObject : \(directObject)")
+        }
+        if let appleEvent = command.appleEvent  { // keyDirectObject
+            print("appleEvent : \(appleEvent)")
+            if let subjectDescriptor = appleEvent.attributeDescriptor(forKeyword:"subj".FourCharCode()) {
+                print("subjectDescriptor : \(subjectDescriptor)")
+                let subjectObjectSpecifier = NSScriptObjectSpecifier(descriptor:subjectDescriptor)
+                let subjects = subjectObjectSpecifier?.objectsByEvaluatingSpecifier
+                print("resolvedSubjects : \(subjects)")
+            }
+        }
+        let commandDescription = command.commandDescription
+        print("commandDescription : \(commandDescription)")
+        
+        let (account, folder) = self.accountAndFolderForNewFeed(appleEvent:command.appleEvent)
+        let scriptableAccount = ScriptableAccount(account)
+        guard let arguments = command.arguments else {return nil}
+        guard let newObjectClass = arguments["ObjectClass"] as? Int else {return nil}
+        guard (newObjectClass.FourCharCode() == "Feed".FourCharCode()) else {return nil}
+        guard let url = self.urlForNewFeed(arguments:arguments) else {return nil}
+        
+        if let existingFeed = account.existingFeed(withURL:url) {
+            return ScriptableFeed(existingFeed, container:scriptableAccount)
+        }
+    
+        // at this point, we have to download the feed and parse it.
+        // RS Parser does the callback for the download on the main thread
+        // because we can't wait here (on the main thread, maybe) for the callback, we have to return from this function
+        // generally, the means handling the appleEvent is over, but to prevent the apple event from returning
+        // we call suspendExecution here.  When we get the callback, we can resume execution
+        command.suspendExecution()
+        
+        self.parsedFeedForURL(url, { (parsedFeedOptional) in
+            if let parsedFeed = parsedFeedOptional {
+                let titleFromFeed = parsedFeed.title
+                let titleFromArgs = arguments["name"] as? String
+             
+                guard let feed = account.createFeed(with: titleFromFeed, editedName: titleFromArgs, url: url) else {
+                    command.resumeExecution(withResult:nil)
+                    return
+                }
+                account.update(feed, with:parsedFeed, {})
+                
+                // add the feed, puttin git in a folder if needed
+                if account.addFeed(feed, to: folder) {
+                    NotificationCenter.default.post(name: .UserDidAddFeed, object: self, userInfo: [UserInfoKey.feed: feed])
+                }
+
+                let resolvedKeyDictionary = command.resolvedKeyDictionary
+                print("resolvedKeyDictionary : \(resolvedKeyDictionary)")
+                let scriptableFeed = ScriptableFeed(feed, container:ScriptableAccount(account))
+                command.resumeExecution(withResult:scriptableFeed.objectSpecifier)
+            } else {
+                command.resumeExecution(withResult:nil)
+            }
+        })
+        return nil
+    }
+ 
+
+ 
 
     // MARK: --- Scriptable properties ---