public static date FindOrAddDate(DateTime objDateTime)
        {
            try
            {
                using (straad_generaldesktopapplication_pcpcpcpc_001Entities objContext = new straad_generaldesktopapplication_pcpcpcpc_001Entities())
                {
                    date objDate = objContext.dates.Where(d => d.date_value__date == objDateTime.Date).FirstOrDefault();

                    if (objDate == null)
                    {
                        Guid objGuid;
                        do
                        {
                            objGuid = Guid.NewGuid();
                        } while (objContext.dates.Where(d => d.date_uuid__uniqueidentifier == objGuid).Count() > 0);

                        objContext.dates.Add(new date()
                        {
                            date_uuid__uniqueidentifier = objGuid, date_value__date = objDateTime
                        });
                        objContext.SaveChanges();

                        return(objContext.dates.Where(d => d.date_uuid__uniqueidentifier == objGuid).FirstOrDefault());
                    }
                    else
                    {
                        return(objDate);
                    }
                }
            }
            catch { }

            return(null);
        }
 public employee(int number, string name, date bd, date hd)
 {
     this.name    = name;
     this.number  = number;
     hire_date    = hd;
     Emplye_birth = bd;
 }
Esempio n. 3
0
        public IActionResult getCustomer1([FromBody] date model)
        {
            var data = new List <User>();
            var user = new UserInfo();

            user.message = 0;
            try
            {
                var dateeee = DateTime.Now.Day;
                if (model.firstDate != null && model.seconedDate != null)
                {
                    var first   = Convert.ToDateTime(model.firstDate);
                    var Seconed = Convert.ToDateTime(model.seconedDate);
                    data         = db.Users.Where(x => x.DateTime.Value.Date >= first.Date && x.DateTime.Value.Date <= Seconed.Date).ToList();
                    user.lenght  = data.Count();
                    user.message = 1;
                    var first1   = Convert.ToDateTime(model.firstDate);
                    var Seconed2 = Convert.ToDateTime(model.seconedDate);
                    user.date = first1.Date.ToShortDateString() + " to " + Seconed2.Date.ToShortDateString();
                }
            }
            catch (Exception ex)
            {
                return(Ok(ex));
            }
            return(Ok(user));
        }
    static void Main()
    {
        date today = new date(7, 10, 1985);
        date tomoz = new date();

        tomorrow = today++;

        tomorrow.Print();      // prints "7/10/1985" i.e. doesn't increment
        Console.Read();
    }
Esempio n. 5
0
 static void affichestruct(date ladate)
 {
     Console.WriteLine("Année    : {0}", ladate.annee);
     Console.WriteLine("Mois     : {0}", ladate.mois);
     Console.WriteLine("Jour     : {0}", ladate.jour);
     Console.WriteLine("Heure    : {0}", ladate.heureprecise.heures);
     Console.WriteLine("Minute   : {0}", ladate.heureprecise.minutes);
     Console.WriteLine("Seconde  : {0}", ladate.heureprecise.secondes);
     Console.WriteLine("\n\n");
 }
Esempio n. 6
0
        private void btnSave_ClickEvent(object sender, EventArgs e)
        {
            var result = CompareDates(dateTimePicker1.Text, dateTimePicker2.Text);

            if (result > 0)
            {
                MessageBox.Show("Please make sure end of term is earlier than resumption of next term. Try again");
                return;
            }
            else if (result == 0)
            {
                MessageBox.Show("Please make sure both dates are not the same. Try again");
                return;
            }
            else
            {
                try
                {
                    using (var db = new Model1())
                    {
                        var dt = db.dates.FirstOrDefault();

                        if (dt != null)
                        {
                            dt.date_declared    = DateTime.Now.ToString("d");
                            dt.next_term_begins = dateTimePicker2.Text;
                            dt.end_of_term      = dateTimePicker1.Text;
                            dt.time_declared    = DateTime.Now;

                            db.SaveChanges();
                            MessageBox.Show("Dates have been updated");
                        }
                        else
                        {
                            var newdate = new date()
                            {
                                date_declared    = DateTime.Now.ToString("d"),
                                next_term_begins = dateTimePicker2.Text,
                                end_of_term      = dateTimePicker1.Text,
                                time_declared    = DateTime.Now
                            };
                            db.dates.Add(newdate);
                            db.SaveChanges();
                            MessageBox.Show("New Dates have been added");
                        }
                    }
                }
                catch (Exception ex)
                {
                    Utils.LogException(ex);
                    MessageBox.Show("Error occured. Please contact support.");
                }
            }
        }
Esempio n. 7
0
        public static date ToDate(byte[] value, int startindex = 0)
        {
            if (value.Length < 4)
            {
                throw new IndexOutOfRangeException();
            }
            date res = new date();

            res.year  = BitProcessor.ToInt16(value, 0 + startindex);
            res.month = value[2 + startindex];
            res.day   = value[3 + startindex];
            return(res);
        }
Esempio n. 8
0
 public DataSetIdentificationType(string encodingSpecification, string encodingSpecificationEdition, string productIdentifier, string productEdition, string applicationProfile, string datasetFileIdentifier, string datasetTitle, date datasetReferenceDate, ISO_639_1 datasetLanguage, MD_TopicCategoryCode[] datasetTopicCategory)
 {
     this.encodingSpecification        = encodingSpecification;
     this.encodingSpecificationEdition = encodingSpecificationEdition;
     this.productIdentifier            = productIdentifier;
     this.productEdition        = productEdition;
     this.applicationProfile    = applicationProfile;
     this.datasetFileIdentifier = datasetFileIdentifier;
     this.datasetTitle          = datasetTitle;
     this.datasetReferenceDate  = datasetReferenceDate;
     this.datasetLanguage       = datasetLanguage;
     this.datasetTopicCategory  = datasetTopicCategory;
 }
Esempio n. 9
0
        public static void CreateGrad()
        {
            Console.Write("Student ID: ");
            long StudID = Console.ReadLine();

            Console.Write("Student Name: ");
            string StudName = Console.ReadLine();

            Console.Write("Date of Birth: ");
            date DateOfBirth = Console.ReadLine();

            Console.Write("Major: ");
            string Major = Console.ReadLine();

            Console.Write("GPA: ");
            float StuRole = Console.ReadLine();

            Console.Write("Previous Degree: ");
            string PreviousDegree = Console.ReadLine();

            Console.Write("Previous Univeristy: ");
            string PreviousUniversity = Console.ReadLine();

            Console.Write("UnderGrad Major: ");
            string UndergradMajor = Console.ReadLine();

            Console.Write("UnderGrad GPA: ");
            string UndergradGPA = Console.ReadLine();


            using (var db = new AppDbContext()){
                List <Grad> Grad = new List <Grad>()
                {
                    new Grad()
                    {
                        StudID             = StudID,
                        StudName           = StudName,
                        DateOfBirth        = DateOfBirth,
                        Major              = Major,
                        GPA                = GPA,
                        PreviousDegree     = PreviousDegree,
                        PreviousUniversity = PreviousUniversity,
                        UndergradMajor     = UndergradMajor,
                        UndergradGPA       = UndergradGPA
                    }
                };
                db.Grad.AddRange(Grad);
                db.SaveChanges();
            }
            Console.WriteLine("Record has been added successfully.");
        }
Esempio n. 10
0
    static string start(Relógio relogio)
    {
        int  min          = 0;
        date milisecSleep = null;
        date them         = null;

        while (relogio.halfdays > 0)
        {
            now          = DateTime.now;
            min          = (relogio.halfdays % 2) == 0 ? 2 : 1;
            milisecSleep = (1000 * 60 * min / relogio.speed);
            them         = now + milisecSleep
                           if (them <= now)
            {
                relogio.halfdays--;
            }
        }
    }
Esempio n. 11
0
        public static void CreateUnderGrad()
        {
            Console.Write("Student ID: ");
            long StudID = Console.ReadLine();

            Console.Write("Student Name: ");
            string StudName = Console.ReadLine();

            Console.Write("Date of Birth: ");
            date DateOfBirth = Console.ReadLine();

            Console.Write("Major: ");
            string Major = Console.ReadLine();

            Console.Write("GPA: ");
            float StuRole = Console.ReadLine();

            Console.Write("Previous High School: ");
            string PreviousHSchool = Console.ReadLine();

            Console.Write("Classification: ");
            string StudClass = Console.ReadLine();


            using (var db = new AppDbContext()){
                List <UnderGrad> UnderGrad = new List <UnderGrad>()
                {
                    new UnderGrad()
                    {
                        StudID          = StudID,
                        StudName        = StudName,
                        DateOfBirth     = DateOfBirth,
                        Major           = Major,
                        GPA             = GPA,
                        PreviousHSchool = PreviousHSchool,
                        StudClass       = StudClass
                    }
                };
                db.UnderGrad.AddRange(UnderGrad);
                db.SaveChanges();
            }
            Console.WriteLine("Record has been added successfully.");
        }
        public static session CreateSession(user objUser)
        {
            try
            {
                using (ModelContext objContext = new ModelContext())
                {
                    Guid objGuid;
                    do
                    {
                        objGuid = Guid.NewGuid();
                    } while (objContext.sessions.Where(s => s.sess_uuid__uniqueidentifier == objGuid).Count() > 0);

                    date objDate = BDate.FindOrAddDate(DateTime.Now);

                    session objSession;

                    objSession = new session()
                    {
                        sess_uuid__uniqueidentifier         = Guid.NewGuid(),
                        sess_starttime__time                = TimeSpan.Parse(DateTime.Now.Hour + ":" + DateTime.Now.Minute + ":" + DateTime.Now.Second),
                        sess_lastactivity__time             = TimeSpan.Parse(DateTime.Now.Hour + ":" + DateTime.Now.Minute + ":" + DateTime.Now.Second),
                        sess_ipbatch01__tinyint             = null,
                        sess_ipbatch02__tinyint             = null,
                        sess_ipbatch03__tinyint             = null,
                        sess_ipbatch04__tinyint             = null,
                        sess_extradata__nvarchar            = null,
                        date_uuid__uniqueidentifier         = objDate.date_uuid__uniqueidentifier,
                        user_uuid_created__uniqueidentifier = objUser.user_uuid__uniqueidentifier
                    };

                    objContext.sessions.Add(objSession);

                    objContext.SaveChanges();

                    return(objContext.sessions.Where(s => s.sess_uuid__uniqueidentifier == objSession.sess_uuid__uniqueidentifier).FirstOrDefault());
                }
            }
            catch { }

            return(null);
        }
Esempio n. 13
0
 public Person(string firstname, string lastname, date birthday)
 {
     this.FirstName = firstname;
     this.LastName  = lastname;
     this.Birthday  = birthday;
 }
 => $"{date:ddd dd MMM yyyy HH:mm} {GetTimezoneAbbreviation(date, timezone)}";
        internal AIMLTagHandler GetTagHandlerU(User user, SubQuery query, Request request, Result result, XmlNode node, bool liText)
        {
            AIMLTagHandler tagHandlerU   = getBespokeTags(user, query, request, result, node);
            string         nodeNameLower = StaticAIMLUtils.ToLower(node.LocalName);
            AltBot         targetBot     = query.TargetBot;

            if (Equals(null, tagHandlerU))
            {
                switch (nodeNameLower)
                {
                case "template":
                case "answer":     //CML
                    tagHandlerU = new template(targetBot, user, query, request, result, node);
                    break;

                case "aiml":
                case "cml":     //CML
                    tagHandlerU = new aiml(targetBot, user, query, request, result, node);
                    break;

                case "aimlexec":
                case "eval":
                    tagHandlerU = new aimlexec(targetBot, user, query, request, result, node);
                    break;

                case "vars":
                case "root":
                case "predicates":     //CML
                    tagHandlerU = new root(targetBot, user, query, request, result, node, (() => query.TargetSettings));
                    break;

                case "properties":
                case "bots":
                    tagHandlerU = new root(targetBot, user, query, request, result, node,
                                           (() => request.TargetBot.GlobalSettings));
                    break;

                case "substitutions":
                    tagHandlerU = new root(targetBot, user, query, request, result, node,
                                           (() => request.TargetBot.InputSubstitutions));
                    break;

                case "topic":
                case "conversation":     //CML
                    tagHandlerU = new topic(targetBot, user, query, request, result, node);
                    break;

                case "category":
                case "conv":     //CML
                    tagHandlerU = new category(targetBot, user, query, request, result, node);
                    break;

                case "and":
                    tagHandlerU = new and(targetBot, user, query, request, result, node);
                    break;

                case "or":
                    tagHandlerU = new or(targetBot, user, query, request, result, node);
                    break;

                case "optional":
                    tagHandlerU = new optional(targetBot, user, query, request, result, node);
                    break;

                case "isa":
                    tagHandlerU = new isa(targetBot, user, query, request, result, node);
                    break;

                case "bot":
                    tagHandlerU = new bot(targetBot, user, query, request, result, node);
                    break;

                case "condition":
                case "options":     //cml
                    tagHandlerU = new condition_aima(targetBot, user, query, request, result, node);
                    break;

                case "li":
                    if (liText)
                    {
                        tagHandlerU = new liif(targetBot, user, query, request, result, node);
                    }
                    break;

                case "if":
                    tagHandlerU = new liif(targetBot, user, query, request, result, node);
                    break;

                case "personf":
                    tagHandlerU = new format(targetBot, user, query, request, result, node,
                                             new Func <string, string>(HttpUtility.UrlEncode),
                                             null);
                    break;

                case "date":
                    tagHandlerU = new date(targetBot, user, query, request, result, node);
                    break;

                case "formal":
                    tagHandlerU = new formal(targetBot, user, query, request, result, node);
                    break;

                case "gender":
                    tagHandlerU = new gender(targetBot, user, query, request, result, node);
                    break;

                case "get":
                    tagHandlerU = new get(targetBot, user, query, request, result, node);
                    break;

                case "gossip":
                    tagHandlerU = new gossip(targetBot, user, query, request, result, node);
                    break;

                case "get_ip":
                case "id":
                    tagHandlerU = new id(targetBot, user, query, request, result, node);
                    break;

                case "inputreq":
                    tagHandlerU = new inputreq(targetBot, user, query, request, result, node);
                    break;

                case "request":
                    tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
                    break;

                case "input":
                    tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
                    break;

                case "justthat":     // <input index="2"/>
                    tagHandlerU = new input(targetBot, user, query, request, result, node, 2);
                    break;

                case "beforethat":     // <input index="3"/>
                    tagHandlerU = new input(targetBot, user, query, request, result, node, 3);
                    break;

#if !(__MonoCS__)
                case "javascript":
                    tagHandlerU = new javascript(targetBot, user, query, request, result, node);
                    break;
#endif
                case "learn":
                case "load":
                case "noload":     // the commented version of <load>
                    tagHandlerU = new learn(targetBot, user, query, request, result, node);
                    break;

                case "lowercase":
                    tagHandlerU = new lowercase(targetBot, user, query, request, result, node);
                    break;

                case "person":
                    tagHandlerU = new substitute(targetBot, user, query, request, result, node);
                    break;

                case "person2":
                    tagHandlerU = new substitute(targetBot, user, query, request, result, node);
                    break;

                case "random":
                    tagHandlerU = new random(targetBot, user, query, request, result, node);
                    break;

                case "sentence":
                    tagHandlerU = new sentence(targetBot, user, query, request, result, node);
                    break;

                case "set":
                    tagHandlerU = new set(targetBot, user, query, request, result, node);
                    break;

                case "size":
                case "getsize":
                    tagHandlerU = new size(targetBot, user, query, request, result, node);
                    break;

                case "sr":
                    tagHandlerU = new sr(targetBot, user, query, request, result, node);
                    break;

                case "srai_odd":
                    tagHandlerU = new srai_odd(targetBot, user, query, request, result, node);
                    break;

                case "star":
                    tagHandlerU = new star(targetBot, user, query, request, result, node);
                    break;

                case "system":
                    tagHandlerU = new system(targetBot, user, query, request, result, node);
                    break;

                case "that":     //default <that index="1,1"/>
                    tagHandlerU = new that(targetBot, user, query, request, result, node, 1);
                    break;

                case "justbeforethat":     //treated as <that index="2,1"/>
                    tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
                    break;

                case "response":     //treated as <that index="1,1"/>
                    tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
                    break;

                case "thatstar":
                    tagHandlerU = new thatstar(targetBot, user, query, request, result, node);
                    break;

                case "think":
                    tagHandlerU = new think(targetBot, user, query, request, result, node);
                    break;

                case "topicstar":
                    tagHandlerU = new topicstar(targetBot, user, query, request, result, node);
                    break;

                case "uppercase":
                    tagHandlerU = new uppercase(targetBot, user, query, request, result, node);
                    break;

                case "version":
                case "getversion":
                    tagHandlerU = new version(targetBot, user, query, request, result, node);
                    break;

                case "cycsystem":
                    tagHandlerU = new cycsystem(targetBot, user, query, request, result, node);
                    break;

                case "cycretract":
                    tagHandlerU = new cycretract(targetBot, user, query, request, result, node);
                    break;

                case "cycassert":
                    tagHandlerU = new cycassert(targetBot, user, query, request, result, node);
                    break;

                case "cycterm":
                    tagHandlerU = new cycterm(targetBot, user, query, request, result, node);
                    break;

                case "cycquery":
                    tagHandlerU = new cycquery(targetBot, user, query, request, result, node);
                    break;

                case "cyccondition":
                    tagHandlerU = new cyccondition(targetBot, user, query, request, result, node);
                    break;

                case "cycphrase":
                    tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
                    break;

                case "cycparaphrase":
                    tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
                    break;

                case "guard":
                    tagHandlerU = new guard(targetBot, user, query, request, result, node);
                    break;

                case "guardstar":
                    tagHandlerU = new guardstar(targetBot, user, query, request, result, node);
                    break;

                case "cycrandom":
                    tagHandlerU = new cycrandom(targetBot, user, query, request, result, node);
                    break;

                case "tscore":
                    tagHandlerU = new tscore(targetBot, user, query, request, result, node);
                    break;

                case "space":
                    tagHandlerU = new space(targetBot, user, query, request, result, node);
                    break;

                case "markov":
                    tagHandlerU = new markov(targetBot, user, query, request, result, node);
                    break;

                case "soundcode":
                    tagHandlerU = new soundcode(targetBot, user, query, request, result, node);
                    break;

                // MSM
                case "msm":
                    tagHandlerU = new msm(targetBot, user, query, request, result, node);
                    break;

                case "processmsm":
                    tagHandlerU = new process_msm(targetBot, user, query, request, result, node);
                    break;

                case "setstate":
                    tagHandlerU = new setstate(targetBot, user, query, request, result, node);
                    break;

                case "state":
                    tagHandlerU = new state(targetBot, user, query, request, result, node);
                    break;

                case "transition":
                    tagHandlerU = new transition(targetBot, user, query, request, result, node);
                    break;

                case "setevidence":
                    tagHandlerU = new setevidence(targetBot, user, query, request, result, node);
                    break;

                case "evidenceassoc":
                    tagHandlerU = new evidence_assoc(targetBot, user, query, request, result, node);
                    break;

                case "evidencepattern":
                    tagHandlerU = new evidence_pattern(targetBot, user, query, request, result, node);
                    break;

                case "evidencestate":
                    tagHandlerU = new evidencestate(targetBot, user, query, request, result, node);
                    break;

                case "dependentmachine":
                    tagHandlerU = new dependentmachine(targetBot, user, query, request, result, node);
                    break;

                case "responsetopic":
                    tagHandlerU = new response_topic(targetBot, user, query, request, result, node);
                    break;

                case "push":
                    tagHandlerU = new push(targetBot, user, query, request, result, node);
                    break;

                case "pop":
                    tagHandlerU = new pop(targetBot, user, query, request, result, node);
                    break;

                case "peekstack":
                    tagHandlerU = new peekstack(targetBot, user, query, request, result, node);
                    break;

                case "lex":
                    tagHandlerU = new lex(targetBot, user, query, request, result, node);
                    break;

                case "lexset":
                    tagHandlerU = new lexset(targetBot, user, query, request, result, node);
                    break;

                case "lexis":
                    tagHandlerU = new lexis(targetBot, user, query, request, result, node);
                    break;

                case "dbpush":
                    tagHandlerU = new dbpush(targetBot, user, query, request, result, node);
                    break;

                case "dbquery":
                    tagHandlerU = new dbquery(targetBot, user, query, request, result, node);
                    break;

                case "dbupdate":
                    tagHandlerU = new dbupdate(targetBot, user, query, request, result, node);
                    break;

                case "dbdelete":
                    tagHandlerU = new dbdelete(targetBot, user, query, request, result, node);
                    break;

                case "dbload":
                    tagHandlerU = new dbload(targetBot, user, query, request, result, node);
                    break;


                case "regex":
                    tagHandlerU = new regex(targetBot, user, query, request, result, node);
                    break;

                case "bind":     // <bind>#$isa</bind>
                    tagHandlerU = new bind(targetBot, user, query, request, result, node);
                    break;

                case "#text":
                    if (!liText)
                    {
                        return(null);
                    }
                    return(new verbatum(node.Value, targetBot, user, query, request, result, node));

                case "#comment":
                    return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));

                case "br":
                    return(new verbatum("\n", targetBot, user, query, request, result, node));

                case "pre":
                    return(new verbatum(StaticXMLUtils.InnerXmlText(node), targetBot, user, query, request, result, node));

                case "p":
                    return(new verbatum("\n\n", targetBot, user, query, request, result, node));

                case "meta":
                    return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));

                default:
                    break;
                }
            }
            if (tagHandlerU != null)
            {
                return(tagHandlerU);
            }
            if (StaticAIMLUtils.IsHtmlTag(node.Name))
            {
                return(new recursiveVerbatum(node, targetBot, user, query, request, result, node, true));
            }
            if (tagHandlerU == null)
            {
                // "bot", "favorite", "fav"
                foreach (KeyValuePair <string, string> prefix in new[]
                {
                    new KeyValuePair <string, string>("get_", "get"),
                    new KeyValuePair <string, string>("set_", "set"),
                    new KeyValuePair <string, string>("bot_", "bot"),
                    new KeyValuePair <string, string>("favorite_", "bot"),
                    new KeyValuePair <string, string>("favorite", "bot"),
                    new KeyValuePair <string, string>("fav_", "bot"),
                    new KeyValuePair <string, string>("fav", "bot"),

                    new KeyValuePair <string, string>("get", "get"),
                    new KeyValuePair <string, string>("set", "set"),
                    new KeyValuePair <string, string>("bot", "bot"),
                })
                {
                    if (nodeNameLower.StartsWith(prefix.Key) && node.Name.Length > prefix.Key.Length)
                    {
                        string               name    = node.Name.Substring(prefix.Key.Length);
                        XmlNode              pn      = node.ParentNode;
                        LineInfoElementImpl  newnode = StaticXMLUtils.CopyNode(prefix.Value, node, false);
                        XmlAttributeLineInfo atr     = (XmlAttributeLineInfo)newnode.OwnerDocument.CreateAttribute("name");
                        atr.ReadOnly = false;
                        atr.Value    = name;
                        newnode.Attributes.Append(atr);
                        if (node.Name.ToLower() != newnode.Name.ToLower())
                        {
                            writeToLog("AIMLLOADER: converted " + node.OuterXml + " -> " + newnode.OuterXml);
                            return(targetBot.GetTagHandler(newnode, query, request, result, user, liText));
                        }
                        writeToLog("AIMLLOADER: ! convert " + node.OuterXml + " -> " + newnode.OuterXml);
                    }
                }
            }
            if (tagHandlerU != null)
            {
                return(tagHandlerU);
            }
            if (nodeNameLower == "name")
            {
                return(new bot(targetBot, user, query, request, result, node));
            }

            tagHandlerU = new lazyClosure(targetBot, user, query, request, result, node);
            writeToLog("AIMLLOADER:  lazyClosure: " + node.OuterXml);
            return(tagHandlerU);
        }
Esempio n. 16
0
 public virtual void Review(date date, string replyTitle, string text)
 {
     throw new System.NotImplementedException();
 }
Esempio n. 17
0
        // Token: 0x0600008F RID: 143 RVA: 0x00005AE0 File Offset: 0x00004AE0
        private string processNode(XmlNode node, SubQuery query, Request request, Result result, User user)
        {
            if (request.StartedOn.AddMilliseconds(request.bot.TimeOut) < DateTime.Now)
            {
                request.bot.writeToLog(string.Concat(new string[]
                {
                    "WARNING! Request timeout. User: "******" raw input: \"",
                    request.rawInput,
                    "\" processing template: \"",
                    query.Template,
                    "\""
                }));
                request.hasTimedOut = true;
                return(string.Empty);
            }
            string text = node.Name.ToLower();

            if (text == "template")
            {
                StringBuilder stringBuilder = new StringBuilder();
                if (node.HasChildNodes)
                {
                    foreach (object obj in node.ChildNodes)
                    {
                        XmlNode node2 = (XmlNode)obj;
                        stringBuilder.Append(this.processNode(node2, query, request, result, user));
                    }
                }
                return(stringBuilder.ToString());
            }
            AIMLTagHandler aimltagHandler = null;

            aimltagHandler = this.getBespokeTags(user, query, request, result, node);
            if (object.Equals(null, aimltagHandler))
            {
                string key;
                switch (key = text)
                {
                case "bot":
                    aimltagHandler = new bot(this, user, query, request, result, node);
                    goto IL_53F;

                case "condition":
                    aimltagHandler = new condition(this, user, query, request, result, node);
                    goto IL_53F;

                case "date":
                    aimltagHandler = new date(this, user, query, request, result, node);
                    goto IL_53F;

                case "formal":
                    aimltagHandler = new formal(this, user, query, request, result, node);
                    goto IL_53F;

                case "gender":
                    aimltagHandler = new gender(this, user, query, request, result, node);
                    goto IL_53F;

                case "get":
                    aimltagHandler = new get(this, user, query, request, result, node);
                    goto IL_53F;

                case "gossip":
                    aimltagHandler = new gossip(this, user, query, request, result, node);
                    goto IL_53F;

                case "id":
                    aimltagHandler = new id(this, user, query, request, result, node);
                    goto IL_53F;

                case "input":
                    aimltagHandler = new input(this, user, query, request, result, node);
                    goto IL_53F;

                case "javascript":
                    aimltagHandler = new javascript(this, user, query, request, result, node);
                    goto IL_53F;

                case "learn":
                    aimltagHandler = new learn(this, user, query, request, result, node);
                    goto IL_53F;

                case "lowercase":
                    aimltagHandler = new lowercase(this, user, query, request, result, node);
                    goto IL_53F;

                case "person":
                    aimltagHandler = new person(this, user, query, request, result, node);
                    goto IL_53F;

                case "person2":
                    aimltagHandler = new person2(this, user, query, request, result, node);
                    goto IL_53F;

                case "random":
                    aimltagHandler = new random(this, user, query, request, result, node);
                    goto IL_53F;

                case "sentence":
                    aimltagHandler = new sentence(this, user, query, request, result, node);
                    goto IL_53F;

                case "set":
                    aimltagHandler = new set(this, user, query, request, result, node);
                    goto IL_53F;

                case "size":
                    aimltagHandler = new size(this, user, query, request, result, node);
                    goto IL_53F;

                case "sr":
                    aimltagHandler = new sr(this, user, query, request, result, node);
                    goto IL_53F;

                case "srai":
                    aimltagHandler = new srai(this, user, query, request, result, node);
                    goto IL_53F;

                case "star":
                    aimltagHandler = new star(this, user, query, request, result, node);
                    goto IL_53F;

                case "system":
                    aimltagHandler = new system(this, user, query, request, result, node);
                    goto IL_53F;

                case "that":
                    aimltagHandler = new that(this, user, query, request, result, node);
                    goto IL_53F;

                case "thatstar":
                    aimltagHandler = new thatstar(this, user, query, request, result, node);
                    goto IL_53F;

                case "think":
                    aimltagHandler = new think(this, user, query, request, result, node);
                    goto IL_53F;

                case "topicstar":
                    aimltagHandler = new topicstar(this, user, query, request, result, node);
                    goto IL_53F;

                case "uppercase":
                    aimltagHandler = new uppercase(this, user, query, request, result, node);
                    goto IL_53F;

                case "version":
                    aimltagHandler = new version(this, user, query, request, result, node);
                    goto IL_53F;
                }
                aimltagHandler = null;
            }
IL_53F:
            if (object.Equals(null, aimltagHandler))
            {
                return(node.InnerText);
            }
            if (aimltagHandler.isRecursive)
            {
                if (node.HasChildNodes)
                {
                    foreach (object obj2 in node.ChildNodes)
                    {
                        XmlNode xmlNode = (XmlNode)obj2;
                        if (xmlNode.NodeType != XmlNodeType.Text)
                        {
                            xmlNode.InnerXml = this.processNode(xmlNode, query, request, result, user);
                        }
                    }
                }
                return(aimltagHandler.Transform());
            }
            string  str   = aimltagHandler.Transform();
            XmlNode node3 = AIMLTagHandler.getNode("<node>" + str + "</node>");

            if (node3.HasChildNodes)
            {
                StringBuilder stringBuilder2 = new StringBuilder();
                foreach (object obj3 in node3.ChildNodes)
                {
                    XmlNode node4 = (XmlNode)obj3;
                    stringBuilder2.Append(this.processNode(node4, query, request, result, user));
                }
                return(stringBuilder2.ToString());
            }
            return(node3.InnerXml);
        }
Esempio n. 18
0
 keyboardRows.Add(Row.Date(date, dtfi));
 public DiscussionTopic(date date, string topicTitle, string topicText)
 {
 }
 AssertEquals(date, copy);
Esempio n. 21
0
 public static object combine(date date, time time) {
     return new datetime(date.year, date.month, date.day, time.hour, time.minute, time.second, time.microsecond, time.tzinfo);
 }
Esempio n. 22
0
 foreach (var(date, counters) in details)
Esempio n. 23
0
 enriched.Add(new AssetStats(date, totalCount, totalSize));
Esempio n. 24
0
 set => setValue(ref date, value);
Esempio n. 25
0
 public DiscussionTopic(date date, string topicTitle, string topicText)
 {
 }
Esempio n. 26
0
        public Bid(int bidID0, int userID, int auctionID, int itemID, date timeStamp)
		{
            
        }
Esempio n. 27
0
 return new datetime(date.InternalDateTime.Add(delta.TimeSpanWithDaysAndSeconds), delta._microseconds + date._lostMicroseconds, date._tz);
Esempio n. 28
0
 => IsLongRangeForDate(date, timeFrame) ? LongRangeForDate(date, timeFrame) : ShortRangeForDate(date, timeFrame);