Robot network system utilize several modules that provide a URL transfer, supporting HTTP, HTTPS, IMAP, POP3 and SMTP. All these modules were extended by urbiscript functions that provide ready to use web browser and mailing system. With this part of structure you will be able to use your Google account, Facebook profile, mailbox and much more. Network part part of structure use following modules UMail (POCO) or UMail (cURL), UBrowser, UGCalendar (with Google Contacts), UFacebook and UTextTool.

Web browser

Web browser (RSS reader) is a kind of application that it use based mainly on graphical interface. Despite of you can still gets some information from web code source. For this purpose lot of browsing functions were implemented in the UBrowser module. A full copu of this module was integrated to the network part of structure. Please read UBrowser documentation for more detailed descriptions.

   // go to the given address, returns false if any problem occurs inside module (check console information) "address" ); 
   // set on/off redirection, default if true;
   // returns a request status code, ex. 
   // 200 - OK (1xx Informational, 2xx Success, 3xx Redirection, 
   // 4xx Client Error, 5xx Server Error, more here); 
   // returns a request status reason ex. (status = 404, reason = "Not Found"); 
   // get a finall address (after namy redirection), it is usefull to avoid redirection in the future;
   // cookie functions
   // set permission to read cookies, default is false = bool; 
   // get the number of cookies and feed your robot if he is hungry :) 
   // get cookie details as string collection
   // (name, comment, domain, path, max-age, httponly, version, secure, and value) ID );
   // content functions
   // get a raw server response (after tidy process and encoding); 
   // get a formatted content (rawContent) as a form:
   // node_number | node_type | indents node_name:text
   // or
   // attribute_number | node_type | indents attribute_name:attribute_value; 
   // save content to the file
   // type=0 save raw content
   // type=1 save cleaned content
   // type=2 save formatted content"file_name" , type);
   // node walking and searching functions
   // get text of the node given path, see ex. 2 in the UBrowser documentation "XPath" ); 
   // get child nodes given path, see ex. 3 in the UBrowser documentation"XPath"); 
   // get list of attributes and values given node path"XPath"); 
   // get list of elements (node name, list of attributes and text), see ex. 5 in the UBrowser documentation"XPath"); 
   // get a list of positions given pattern, see ex. 6 in the UBrowser documentation"node_name" , [ "attribute1" , "attribute=/"value/""],... ] ); 
   // get a text or attribute value given position, see ex. 7 in the UBrowser documentation, atribute_number);

Email client

According to your needs you can use two kinds of mailing modules. UMail (POCO) utilize POCO library and provides SMTP/POP3 mailbox handling, UMail (cURL) based on cURL library provides SMTP/IMAP mailbox handling. UTextTool must be also enabled. Set the proper options in the robot configuration. For now the network part of robot structure contain two mailbox configurations, for user and for robot use. It can be easy extended with more mailboxes. Remember about password file place configuration.

Sending functions

   // set a sender name["user"|"robot"].send.From("I Robot"); 
   // set a recipent list["user"|"robot"].send.To(["address1","address2",...]); 
   // set a carbon copy recipent list["user"|"robot"].send.Cc(["address3","address4",...]); 
   // set a blind carbon copy recipent list["user"|"robot"].send.Bcc(["address5","address6",...]); 
   // set a subject["user"|"robot"].send.Subject("text"); 
   // set a content (you can use html tags, even links to attachments)["user"|"robot"].send.Content("text"); 
   // add attachments (set a path and name of attached file)["user"|"robot"].send.Attachment(["file1","file2",...]); 
   // available only with UMail (cURL)// set attachments IDs 
   // (see example 2 in the UMail (cURL) documentation)["user"|"robot"].send.AttachmentID(["file1_ID","file2_ID",...]); 
   // load html content data from mailTemplates folder["user"|"robot"].LoadContent("path/to/file.html");
   // perform a sending process, return false if any problem occurs inside module["user"|"robot"].Send();

Receiving functions

   // perform check new (unread) emails, return false if any problem occurs inside module["user"|"robot"].Check();
   // functions available only with UMail (POCO)
   // a number of new emails in the user's INBOX folder["user"|"robot"].receive.newNo;
   // perform download all new emails, return false if any problem occurs inside module["user"|"robot"].Receive();  
   // save all attachements of received new emails, return false if any problem occurs inside module["user"|"robot"].receive.SaveAttachments("path/to/save/");
   // functions available only with UMail (cURL)
   // a list of numbers of new emails in the user's INBOX folder["user"|"robot"].receive.ID; 
   // perform download email process of given ID, return false if any problem occurs inside module["user"|"robot"].Receive("IDx"); 
   // save attachemnts of given ID received email, return false if any problem occurs inside module["user"|"robot"].receive.SaveAttachments(ID,"path/to/save/");
   // these fields in case of UMail (POCO) contains vectors of all new emails data 
   // in case of UMail (cURL) only data from one (downloaded) email
   // get sender name(s)["user"|"robot"].receive.From; 
   // get a main recipient list(s)["user"|"robot"].receive.To; 
   // get a carbon copy recipient list(s)["user"|"robot"].receive.Cc; 
   // get a subject(s)["user"|"robot"].receive.Subject; 
   // get a date of emial(s)["user"|"robot"].receive.Date; 
   // get a plain text content of emial(s)["user"|"robot"].receive.Content; 
   // get a HTML content data of email

Weather forecast

This part of robot network structure utilize UBrowser module and it gets weather forecast from YAHOO weather provider. All needed configuration like your location you can find in the robot configuration. 

   // Get weather forecast;
   // get info about weather location;;;
   // get info about  units;;;;
   // get info about wind;;;
   // get info about atmosphere;;;;
   // get info about sunrise and sunset;;
   // get info about weather condition;;;
   // get 5 day weather forecast;;;;;

News reader (RSS reader)

This part of robot network structure utilize UBrowser and UTextTool module and it gets news from different rss channels. 


   // get news from given rss address"address");
   // number of news;
   // news published date;
   // title of newst;
   // full description;
   // category (optional);


This part of network structure can be use for Facebook social networking service. It is based on UFacebook module and for now has two instances to handle user's FB profile and robot's one. Facebook structure use UTextTool also, so you must enable it in the robot configuration. Using this structure your robot will be able to to post new stories, upload photos (eg. from his camera), retrieve posts and  a variety of other tasks that your FB app might need to do. Use our official "FLASH Connect" facebook application. Read UFacebook module docu for more info.

First, connect "FLASH Connect" app with your FB account. Click FB login button below
   // download some content from web (ex. photo)["user"|"robot"].DownloadContent("link", "path");
   // get user/robot info["user"|"robot"].user.Get();
   // the id of user account["user"|"robot"].user.ID;
   // the user full name["user"|"robot"];
   // the user first name["user"|"robot"].user.firstName;
   // the user last name["user"|"robot"].user.lastName;
   // gender pronoun selected by this person["user"|"robot"].user.gender;
   // the user birthday in the format MM/DD/YYYY["user"|"robot"].user.birthday;
   // the user current location as entered by them on their profile["user"|"robot"].user.location;
   // the user primary email address listed on their profile["user"|"robot"];
   // get user's likes["user"|"robot"].user.GetLikes();
   // the like ID["user"|"robot"].user.likeID;
   // the like Name["user"|"robot"].user.likeName;
   // the like category["user"|"robot"].user.likeCategory;
   // get posts, feed, home
   // posts - get posts created by the user (on her own wall or the wall of a friend), and it may include any kind of content such as shared links, check-ins, photos and status updates,
   // feed - all the things that a user might see on his own wall, shared links, check-ins, photos and status updates. This also includes posts made by friends on the user's wall,
  // home- all the posts created by you and your friends, i.e. what you usually find on the “News Feed” of Facebook,["user"|"robot"].post.GetPosts();["user"|"robot"].post.GetFeed();["user"|"robot"].post.GetHome();
   // post message on the wall["user"|"robot"].post.PutPost("message");
   // post id number["user"|"robot"].post.ID;
   // the user ID who posted the post["user"|"robot"].post.fromID;
   // the user full name who posted the post["user"|"robot"].post.fromName;
   // the post message content["user"|"robot"].post.message;
   // indicating the object type of this post (link, status, photo, video)["user"|"robot"].post.type;
   // description of the type of a status update (mobile_status_update, 
   // created_note, added_photos, added_video, shared_story, created_group, 
   // created_event, wall_post, app_created_story, published_story, 
   // tagged_in_photo, approved_friend)["user"|"robot"].post.statusType;
   // text from stories not intentionally generated by users, such as those 
   // generated when two people become friends, or when someone else posts 
   // on the person's wall["user"|"robot"].post.story;
   // the ID of any uploaded photo or video attached to the post["user"|"robot"].post.objectID;
   // a description of a link in the post["user"|"robot"].post.description;
   // a caption of a link/photo in the post["user"|"robot"].post.caption;
   // the time of the last change to this post, or the comments on it["user"|"robot"].post.updatedTime;
   // returns only status updates posted by the user on his own wall["user"|"robot"].status.Get();
   // the status message ID["user"|"robot"].status.ID;
   // the user ID who posted the message["user"|"robot"].status.fromID;
   // the user full name who posted the message["user"|"robot"].status.fromName;
// the status message content["user"|"robot"].status.message;
// the time the message was published["user"|"robot"].status.updatedTime;
    // get all user albums["user"|"robot"].album.Get();
   // the album ID["user"|"robot"].album.ID;
   // the title of the album["user"|"robot"];
   // number of photos in this album["user"|"robot"].album.count;
   // the type of the album (app, cover, profile, mobile, wall, normal, album)["user"|"robot"].album.type;
   // whether the viewer can upload photos to this album["user"|"robot"].album.canUpload;
   // get all photos in the album["user"|"robot"].photo.Get(album_id); 
   // send a photo to the album
   // name - brief description of the photo
   // source - path or url of the photo["user"|"robot"].photo.Put("album_id", "name", "/path/to/photo/photo.jpg");
   // send a photo on the wall,
   // message - message on the wall
   // photo - path or url of the photo["user"|"robot"].photo.PostOnTimeline("message","/path/to/photo/photo.jpg");
   // the photo ID["user"|"robot"].photo.ID;
   // the user provided caption given to this photo["user"|"robot"];
   // link to the image source of the photo["user"|"robot"].photo.source;
   // the last time the photo or its caption was updated["user"|"robot"].photo.updatedTime;
   // get unread facebook notifications["user"|"robot"].notification.Get(); 
   // clear all pending notifications["user"|"robot"].notification.Clear();
   // the notification's id["user"|"robot"].notification.ID;
   // the id (user, page, app, etc.) that 'sent', or is the 
   // source of the notification["user"|"robot"].notification.fromID;
   // the full name (user, page, app, etc.) that 'sent', or is the 
   // source of the notification,["user"|"robot"].notification.fromName;
   // the message text in the notification["user"|"robot"].notification.message;
   // the message title text in the notification["user"|"robot"].notification.title;
   // the notification type["user"|"robot"].notification.type;
   // the object (this can be a post, a photo, a comment, etc.) 
   // that was the subject of the notification["user"|"robot"].notification.objectID;
   // when the notification was last updated["user"|"robot"].notification.updatedTime;
   // get all unread or unseen messages, mode:["user"|"robot"].message.GetUnread();["user"|"robot"].message.GetUnseen();
   // the ID of a conversation, in a format similar to t_id.000000000000000["user"|"robot"].message.conversationID;
   // the user ID who send the message["user"|"robot"].message.fromID;
   // the user ID who send the message["user"|"robot"].message.fromName;
   // the text of reply["user"|"robot"].message.message;
   // when the notification was created["user"|"robot"].message.createdTime;
   // get all groups["user"|"robot"].group.Get();
   // the group ID["user"|"robot"].group.ID
   // the name of the group["user"|"robot"];
   // Since April 30th, 2014 (FB API 2.0) friends list no longer 
   // includes the full list of a person's friends. Instead, it 
   // now returns the list of that person's friends who are also
   // using your app. 
   // field friends is reserved by urbi syntax
   // get users friends using your app["user"|"robot"].fri_end.Get();
   // the friend ID["user"|"robot"].fri_end.ID;
   // the name of the friend["user"|"robot"];
   // get users events["user"|"robot"].event.Get();
   // the event ID["user"|"robot"].event.ID;
   // the name of the event["user"|"robot"];
   // the location of the event, if any["user"|"robot"].event.location;
   // start time of the event["user"|"robot"].event.startTime;
   // end time of the event["user"|"robot"].event.endTime;
   // long-form description of the event["user"|"robot"].event.description;
   // get list of users likes["user"|"robot"].like.Get("object_id"); 
   // like something["user"|"robot"].like.Put("object_id");
   // the like from ID["user"|"robot"].like.fromID;
   // the like from Name["user"|"robot"].like.fromName;
   // get comments of something["user"|"robot"].comment.Get();
   // comment something["user"|"robot"].comment.Put("object_id", "message"); 
   // get comments from notification["user"|"robot"].comment.GetFromNotifications();
   // the user ID who put the comment["user"|"robot"].comment.fromID;
   // the user name who put the comment["user"|"robot"].comment.fromName;
   // comment text (content)["user"|"robot"].comment.message;

Google Calendar

This part of network structure can be use to handle your Google account (for now Google Calendar and Google Contacts only). It is based on UGCalendar (+Contacts)Calendar (+Contacts) module and for now has two instances to handle user's Account profile and robot's one. Network structurte use UTextTool also, so it must be enabled in the robot configuration. Using this structure your robot will be able to check your personal calendar and get informations about youe everyday events. Getting contacts to your friends robot can send them emials everytime you ask him. Use our official "FLASH Connect" Google application. Read UGCalendar (+Contacts)Calendar (+Contacts) module docu for more info.

// get list of calendars info["user"|"robot"].calendar.Get();
// identifiers of the calendars["user"|"robot"].calendar.ID;
// titles of the calendars["user"|"robot"].calendar.summary;
// descriptions of the calendars["user"|"robot"].calendar.description;
// geographic locations of the calendars as free-form text["user"|"robot"].calendar.location;
// the time zones of the calendars["user"|"robot"].calendar.timeZone;
   // get list of calendar events 
   // "calendar_ID" - identifiers of the calendar,
   // "from date" - optional start time in format "YYYY-MM-YY HH:MM:SS" or "YYYY-MM-YY"
   // "to date" - optional end time in format "YYYY-MM-YY HH:MM:SS" or "YYYY-MM-YY"["user"|"robot"].event.Get("calendar_ID","from_date","to_date");
   // get list of calendar events by calendar name["user"|"robot"].event.GetFromCalendarName("calendar_name","start_time","end_time");
   // get list of calendar events starting from today["user"|"robot"].event.GetFromToday("calendar_name");
   // get list of calendar events starting from now["user"|"robot"].event.GetFromNow("calendar_name");
   // get list of calendar events for today only["user"|"robot"].event.GetForToday("calendar_name");
   // get list of calendar events for today only, starting from now["user"|"robot"].event.GetForTodayFromNow("calendar_name");
   // set one evnt in the given calendar,
   // "calendar_ID" - identifiers of the calendar,
   // "summary" - title of the event,
   // "location" - location of the event
   // "start time" - start time of the event in format "YYYY-MM-YY HH:MM:SS" or "YYYY-MM-YY"
   // "end time" - end time of the event in format "YYYY-MM-YY HH:MM:SS" or "YYYY-MM-YY"
   // email - number of minutes before the start of the event when the reminder should send 
   // via email (-1 - no email reminder),
   // popup - number of minutes before the start of the event when the reminder should send 
   // via popup UI (-1 - no popup reminder),
   // sms - number of minutes before the start of the event when the reminder should send 
   // via sms (-1 - no sms reminder)["user"|"robot"].event.Set("calendar_ID", "summary", "location", "start_time", "end_time","email", "popup", "sms");
   // identifiers of the events["user"|"robot"].event.ID;
   // titles of the events["user"|"robot"].event.summary;
   // descriptions of the events["user"|"robot"].event.description;
   // geographic locations of the eventss as free-form text["user"|"robot"].event.location;
   // the (inclusive) start time of the events["user"|"robot"].event.startTime;
   // the (exclusive) end time of the events["user"|"robot"].event.endTime;

Google Contacts

See description to Google Calendar.
   // get list of contact group info["user"].group.Get();
   // identifiers of the contact group["user"].group.ID;
   // titles of the contact group["user"].group.title;
   // get list of contacts from group["user"].contact.Get("group_ID");
   // get list of contacts from group by name["user"].contact.GetFromGroupName("group_name");
   // identifiers of the contacts["user"].contact.ID;
   // titles of the contacts["user"].contact.title;
   // emails of the contacts["user"];
   // phones of the contacts["user"];

Other network tools

This function can be useful not only with network part of structure. It utilize UTextTool module.

   // get name of the day of the week"date_in");



EMYS and FLASH are Open Source and distributed according to the GPL v2.0 © Rev. 0.8.0, 27.04.2016

FLASH Documentation