/// <summary> /// Must be used only for InputItems created by own constructor /// if InputItem was created by own constructor, its base parameters should be set /// </summary> /// <typeparam name="ItemT"></typeparam> /// <param name="parent_item"></param> /// <param name="item"></param> /// <returns></returns> static internal bool Add2Queue <ItemT>(InputItemQueue queue, InputItem parent_item, ItemT item) where ItemT : InputItem { item.set_parent_members(parent_item); item.set_tag_item_members(); typeof(Item).GetField("__Id", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(item, Session.This.GetNewItemId()); return(item.add2queue(queue)); }
void read_input_file() { Type start_input_item_type = (from t in Assembly.GetEntryAssembly().GetTypes() where t.IsSubclassOf(typeof(InputItem)) && !t.IsGenericType select t).First(); InputItemQueue start_input_item_queue = GetInputItemQueue(start_input_item_type.Name); CustomizationApi.FillStartInputItemQueue(start_input_item_queue, start_input_item_type); }
/// <summary> /// This is the ONLY method to add a queue! /// When a queue is constructed dynamicly, it is possible to set its order. /// </summary> /// <param name="queue_name"></param> /// <param name="position"></param> static public void SetInputItemQueuePosition(string queue_name, int position) { lock (This.input_item_queue_name2input_item_queues) { InputItemQueue iiq = (InputItemQueue)This.input_item_queue_name2input_item_queues[queue_name]; if (iiq == null) { iiq = new InputItemQueue(queue_name); } else { iiq = (InputItemQueue)This.input_item_queue_name2input_item_queues[queue_name]; int p = iiq.Position; if (p == position) { return; } This.input_item_queue_name2input_item_queues.RemoveAt(p); position--; } This.input_item_queue_name2input_item_queues.Insert(position, queue_name, iiq); for (int i = 0; i < This.input_item_queue_name2input_item_queues.Count; i++) { ((InputItemQueue)This.input_item_queue_name2input_item_queues[i]).Position = i; } This.LogInputItemQueuePosition(iiq); } }
virtual public void __FillStartInputItemQueue(InputItemQueue start_input_item_queue, Type start_input_item_type) { Log.Main.Write("Filling queue of " + start_input_item_queue.Name + " with input file."); if (!File.Exists(Settings.Input.File)) { throw (new Exception("Input file " + Settings.Input.File + " does not exist.")); } if (Path.GetExtension(Settings.Input.File).StartsWith(".xls", StringComparison.InvariantCultureIgnoreCase)) { throw new Exception("Reading excel is not supported"); } FileReader fr = new FileReader(Settings.Input.File, Settings.Input.FileFormat); for (FileReader.Row r = fr.ReadLine(); r != null; r = fr.ReadLine()) { InputItem.Add2QueueBeforeStart(start_input_item_queue, start_input_item_type, r.Headers.ToDictionary(x => x, x => r[x])); } if (start_input_item_queue.CountOfNew < 1) { LogMessage.Error("Input queue is empty so nothing is to do. Check your input data."); } }
/// <summary> /// Must be used ONLY before bot cycle started as no parent item is accepted. Usually used while feeding by input file. /// </summary> /// <param name="item_type"></param> /// <param name="field_value_pairs"></param> /// <returns></returns> static internal bool Add2QueueBeforeStart(InputItemQueue queue, Type item_type, Dictionary <string, string> field2value) { InputItem item = (InputItem)FormatterServices.GetUninitializedObject(item_type); Dictionary <string, FieldInfo> serialized_field_name2serialized_field_fis = item_types2serialized_field_names2serialized_field_fi[item_type]; foreach (string field in field2value.Keys) { try { FieldInfo fi = serialized_field_name2serialized_field_fis[field]; fi.SetValue(item, Convert.ChangeType(field2value[field], fi.FieldType)); } catch (Exception e) { throw new Exception("Field '" + field + "' does not exist.\n" + e.Message); } } ConstructorInfo ci; if (item_types2constructor_info.TryGetValue(item_type, out ci)) { ci.Invoke(item, new object[] {}); } typeof(Item).GetField("__Id", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(item, Session.This.GetNewItemId()); return(item.add2queue(queue)); }
void read_input_file() { Log.Main.Write("Loading InputItems from the input file."); Type start_input_item_type = (from t in Assembly.GetEntryAssembly().GetTypes() where t.IsSubclassOf(typeof(InputItem)) && !t.IsGenericType select t).First(); InputItemQueue start_input_item_queue = GetInputItemQueue(start_input_item_type.Name); __FillStartInputItemQueue(start_input_item_queue, start_input_item_type); }
internal static void FillStartInputItemQueue(InputItemQueue start_input_item_queue, Type start_input_item_type) { fill_start_input_item_queue.Invoke(start_input_item_queue, start_input_item_type); if (start_input_item_queue.CountOfNew < 1) { LogMessage.Error("Input queue is empty so nothing is to do. Check your input data."); } }
static internal bool Add2Queue <ItemT>(InputItemQueue queue, InputItem parent_item, object anonymous_object) where ItemT : InputItem { ItemT item = Item.Create <ItemT>(anonymous_object); item.set_parent_members(parent_item); item.set_tag_item_members(); return(item.add2queue(queue)); }
/// <summary> /// Add item to queue. It is possible to create a named queue. /// Preferred method for adding items. /// </summary> /// <param name="queue_name"></param> /// <param name="item"></param> /// <returns></returns> public bool Add(string queue_name, InputItem item) { if (queue_name == null) { queue_name = item.GetType().Name; } InputItemQueue iiq = Session.GetInputItemQueue(queue_name); return(InputItem.Add2Queue(iiq, current_item, item)); }
/// <summary> /// Add item to queue. It is possible to create a named queue. /// It is the same like BotCycle.Add() but not so efficient. /// </summary> /// <param name="queue_name"></param> /// <param name="item"></param> static public bool Add(string queue_name, InputItem item) { if (queue_name == null) { queue_name = item.GetType().Name; } InputItemQueue iiq = Session.GetInputItemQueue(queue_name); return(InputItem.Add2Queue(iiq, BotCycle.GetCurrentInputItemForThisThread(), item)); }
internal static InputItem Restore(InputItemQueue queue, Type item_type, string item_seed, int item_id, InputItem parent_item, Dictionary <string, TagItem> field2tag_items) { InputItem item = (InputItem)Item.Restore(item_type, item_seed, item_id); item.set_parent_members(parent_item); foreach (KeyValuePair <string, TagItem> kv in field2tag_items) { item_type.GetField(kv.Key).SetValue(item, kv.Value); } item.add2queue(queue); return(item); }
internal void WriteInputItemQueuePosition(InputItemQueue queue) { if (!Settings.Engine.WriteSessionRestoringLog) { return; } if (!restoring) { writeElement(QueueTag, new { name = queue.Name, position = queue.Position }); } }
static public InputItemQueue GetInputItemQueue(string queue_name) { lock (This.input_item_queue_name2input_item_queues) { InputItemQueue iiq = (InputItemQueue)This.input_item_queue_name2input_item_queues[queue_name]; if (iiq == null) { SetInputItemQueuePosition(queue_name, 0); iiq = (InputItemQueue)This.input_item_queue_name2input_item_queues[queue_name]; } return(iiq); } }
static public void FillStartInputItemQueue(InputItemQueue start_input_item_queue, Type start_input_item_type) { Log.Main.Write("Filling queue of " + start_input_item_queue.Name + " with input file."); if (!File.Exists(Properties.Input.Default.InputFile)) { throw (new Exception("Input file " + Properties.Input.Default.InputFile + " does not exist.")); } if (Path.GetExtension(Properties.Input.Default.InputFile).StartsWith(".xls", StringComparison.InvariantCultureIgnoreCase)) { throw new Exception("Reading excel was not implemented"); } FileReader fr = new FileReader(Properties.Input.Default.InputFile, Properties.Input.Default.InputFieldSeparator); for (FileReader.Row r = fr.ReadLine(); r != null; r = fr.ReadLine()) { InputItem.Add2QueueBeforeStart(start_input_item_queue, start_input_item_type, r.Headers.ToDictionary(x => x, x => r[x])); } }
//internal void LogInputItemQueueOrder() //{ // if (items_xtw == null) // return; // lock (this) // { // try // { // items_xtw.WriteStartElement("__QueueOrder"); // List<string> iiqns = new List<string>(); // foreach (string iiqn in input_item_queue_name2input_item_queues.Keys) // iiqns.Add(iiqn); // items_xtw.WriteString(string.Join("\n", iiqns)); // items_xtw.WriteEndElement(); // } // catch (Exception e) // { // LogMessage.Exit(e); // } // items_xtw.Flush(); // } //} internal void LogInputItemQueuePosition(InputItemQueue queue) { if (items_xtw == null) { return; } lock (this) { try { items_xtw.WriteStartElement("__Queue"); items_xtw.WriteAttributeString("name", queue.Name); items_xtw.WriteAttributeString("position", queue.Position.ToString()); items_xtw.WriteEndElement(); } catch (Exception e) { LogMessage.Exit(e); } items_xtw.Flush(); } }
void Session_InputItemQueueProgress(InputItemQueue input_item_queue, int total_item_count, int processed_item_count) { This.DisplayStatus(input_item_queue.Name, "taken " + processed_item_count.ToString() + " /remain " + (total_item_count - processed_item_count).ToString()); if (ProgressBarInputItemQueueName == input_item_queue.Name) This.display_progress(total_item_count, processed_item_count); }
internal static void FillStartInputItemQueue(InputItemQueue start_input_item_queue, Type start_input_item_type) { fill_start_input_item_queue.Invoke(start_input_item_queue, start_input_item_type); if (start_input_item_queue.CountOfNew < 1) LogMessage.Error("Input queue is empty so nothing is to do. Check your input data."); }
/// <summary> /// Add item as dynamic object to queue. It is possible to create a named queue. /// It is the same like BotCycle.Add() but not so efficient and safe. /// </summary> /// <typeparam name="ItemT"></typeparam> /// <param name="queue_name"></param> /// <param name="anonymous_object"></param> /// <returns></returns> static public bool Add <ItemT>(string queue_name, object anonymous_object) where ItemT : InputItem { InputItemQueue iiq = Session.GetInputItemQueue(queue_name); return(InputItem.Add2Queue <ItemT>(iiq, BotCycle.GetCurrentInputItemForThisThread(), anonymous_object)); }
void close() { lock (This_) { BotCycle.Abort(); if (This.items_xtw != null) { This.items_xtw.WriteEndElement(); This.items_xtw.WriteEndDocument(); This.items_xtw.Close(); } if (This.input_item_queue_name2input_item_queues.Count > 0) { if (This.IsUnprocessedInputItem) { This.set_session_state(SessionState.ABORTED); } else if (This.IsItem2Restore) { This.set_session_state(SessionState.UNCOMPLETED); } else { This.set_session_state(SessionState.COMPLETED); } } This.workflow_xtw.WriteEndElement(); This.workflow_xtw.WriteEndDocument(); This.workflow_xtw.Close(); try { CustomizationApi.SessionClosing(); } catch (Exception e) { LogMessage.Error(e); } try { if (Closing != null) { Closing.Invoke(); } } catch (Exception e) { LogMessage.Error(e); } InputItemQueue.Close(); FileWriter.ClearSession(); Cache.ClearSession(); Proxies.ClearSession(); WebRoutine.ClearSession(); Log.Main.Write("Closing session."); Cliver.Log.ClearSession(); This_ = null; } }
bool add2queue(InputItemQueue queue) { __State = InputItemState.NEW; this.GetType().GetField("__Queue", BindingFlags.Instance | BindingFlags.Public).SetValue(this, queue); return(__Queue.Enqueue(this)); }
void close() { lock (This_) { try { Log.Main.Write("Closing the bot session: " + Session.State.ToString()); BotCycle.Abort(); if (This.IsUnprocessedInputItem) { State = SessionState.BROKEN; } else if (This.IsItem2Restore) { State = SessionState.UNCOMPLETED; } else { State = SessionState.COMPLETED; } This.Storage.WriteState(State, new { }); try { __Closing(); } catch (Exception e) { Session.State = SessionState.FATAL_ERROR; This.Storage.WriteState(State, new { }); LogMessage.Error(e); __ErrorClosing(e.Message); } try { Closing?.Invoke(); } catch (Exception e) { Session.State = SessionState.FATAL_ERROR; This.Storage.WriteState(State, new { }); LogMessage.Error(e); __ErrorClosing(e.Message); } InputItemQueue.Close(); FileWriter.ClearSession(); } catch (ThreadAbortException) { } catch (Exception e) { Session.State = SessionState.FATAL_ERROR; This.Storage.WriteState(State, new { }); LogMessage.Error(e); __ErrorClosing(e.Message); } finally { Storage.Close(); switch (State) { case SessionState.NULL: case SessionState.STARTING: case SessionState.COMPLETED: case SessionState.FATAL_ERROR: Directory.Move(Dir, Dir + "_" + TimeMark + "_" + State); break; case SessionState.RESTORING: case SessionState.RUNNING: case SessionState.CLOSING: case SessionState.UNCOMPLETED: case SessionState.BROKEN: case SessionState.NONFATAL_ERROR: break; default: throw new Exception("Unknown option: " + State); } This_ = null; Cliver.Log.Head.Close(false); } } try { Closed?.Invoke(); } catch (Exception e) { LogMessage.Error(e); __ErrorClosing(e.Message); } }
/// <summary> /// Add item as dynamic object to queue. It is possible to create a named queue. /// Preferred method for adding items. /// </summary> /// <typeparam name="ItemT"></typeparam> /// <param name="queue_name"></param> /// <param name="anonymous_object"></param> /// <returns></returns> public bool Add <ItemT>(string queue_name, object anonymous_object) where ItemT : InputItem { InputItemQueue iiq = Session.GetInputItemQueue(queue_name); return(InputItem.Add2Queue <ItemT>(iiq, current_item, anonymous_object)); }
internal void WriteInputItemQueuePosition(InputItemQueue queue) { if (!Settings.Engine.WriteSessionRestoringLog) return; if (!restoring) writeElement("__Queue", new { name = queue.Name, position = queue.Position }); }
public static int CountOfProcessed <InputItemT>() where InputItemT : InputItem { InputItemQueue iiq = Session.GetInputItemQueue(typeof(InputItemT).Name); return(iiq.CountOfProcessed); }