Example #1
0
 public SleepStep(Point markedPoint, Bedroom markedBedroom, FullTask parentList)
     : base(null, parentList, TaskType.SLEEP)
 {
     this.markedBedroom = markedBedroom;
     this.markedPoint = markedPoint;
     this.WhereToPlace = markedBedroom;
 }
Example #2
0
        public BuildStep(Point onlyPoint, Building toBuild, FullTask parentList)
            : base(null, parentList, TaskType.BUILD)
        {
            this.ToBuild = toBuild;

            this.startPoint = onlyPoint;
            this.endPoint = onlyPoint;

            checkIfBuildActionMakesSense();
        }
Example #3
0
        public BuildStep(Path path, Building toBuild, FullTask parentList)
            : base(path, parentList, TaskType.BUILD)
        {
            this.ToBuild = toBuild;

            this.startPoint = path.Start;
            this.endPoint = path.End;

            checkIfBuildActionMakesSense();
        }
Example #4
0
        public StockpileStep(Path path, Carryable toDropOff, Building stockpile, FullTask parentList)
            : base(path, parentList, TaskType.PUT_DOWN)
        {
            this.ToDropOff = toDropOff;
            this.WhereToPlace = stockpile;

            this.endPoint = path.End;

            if (Path.Start != StartPoint)
                throw new ArgumentException("Path doesn't start where we picked up the item!");
        }
Example #5
0
        public PickupStep(Path path, FullTask parentList, Carryable item)
            : base(path, parentList, TaskType.PICK_UP)
        {
            this.ToPickUp = item;

            if (path != null)
            {
                this.startPoint = path.Start;

                if (path.End != EndPoint)
                    throw new ArgumentException("The path doesn't end at the item we're picking up!");
            }
            else
            {
                this.startPoint = item.SquareCoordinate;
            }
        }
Example #6
0
        public List <FullTask> DBTaskSearch(SQLiteConnection sqldb, string criteria = "", string teacher = "", string id = "", string classcriteria = "", int orderby = 0, bool deleted = false, bool hidden = false, bool HideMarked = false)
        {
            //Input validation
            criteria      = criteria.ToLower().Trim();
            teacher       = teacher.ToLower().Trim();
            id            = id.ToLower().Trim();
            classcriteria = classcriteria.ToLower().Trim();

            //Return the table in array form
            IEnumerable <FullTask> result = null;

            if (HideMarked)
            {
                result = sqldb.GetAllWithChildren <FullTask>(pv => pv.title.ToLower().Contains(criteria) && pv.deleted == deleted && pv.hideFromRecipients == hidden && pv.mark == 0).AsEnumerable();
            }
            else
            {
                result = sqldb.GetAllWithChildren <FullTask>(pv => pv.title.ToLower().Contains(criteria) && pv.deleted == deleted && pv.hideFromRecipients == hidden).AsEnumerable();
            }
            switch (orderby)
            {
            case 1:
                //Oldest activity
                result = result.OrderBy(pv => pv.LatestestActivity);

                break;

            case 2:
                //Latest due
                result = result.OrderByDescending(pv => pv.dueDate);
                break;

            case 3:
                //Oldest due
                result = result.OrderBy(pv => pv.dueDate);

                break;

            case 4:
                //latest set
                result = result.OrderByDescending(pv => pv.setDate);

                break;

            case 5:
                //oldest set
                result = result.OrderBy(pv => pv.setDate);

                break;

            default:
                //latest activity
                result = result.OrderByDescending(pv => pv.LatestestActivity);

                break;
            }


            List <FullTask> fullTasks = new List <FullTask>();

            if (teacher == "" && classcriteria == "")
            {
                foreach (var item in result)
                {
                    if (item.id.ToString().Contains(id))
                    {
                        FullTask k = item;
                        try
                        {
                            if (k.BlobPrincipal != null)
                            {
                                k.setter = JsonConvert.DeserializeObject <Principal>(k.BlobPrincipal);
                            }
                            if (k.BlobAddressees != null)
                            {
                                k.addressees = JsonConvert.DeserializeObject <Address[]>(k.BlobAddressees);
                            }
                            if (k.BlobCoowner != null)
                            {
                                k.coowners = JsonConvert.DeserializeObject <Principal[]>(k.BlobCoowner);
                            }
                            if (k.BlobRecipientStatuses != null)
                            {
                                k.recipientStatuses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BlobRecipientStatuses);
                            }
                            if (k.BloballRecipients != null)
                            {
                                k.allRecipientsResponses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BloballRecipients);
                            }
                            if (k.BlobDescription != null)
                            {
                                k.descriptionDetails = JsonConvert.DeserializeObject <DescriptionDetails>(k.BlobDescription);
                            }
                            if (k.BlobFileAttachment != null)
                            {
                                k.fileAttachments = JsonConvert.DeserializeObject <FileAttachments[]>(k.BlobFileAttachment);
                            }
                            if (k.BlobPageAttachment != null)
                            {
                                k.pageAttachments = JsonConvert.DeserializeObject <PageAttachments[]>(k.BlobPageAttachment);
                            }
                            if (k.BlobRecipients != null)
                            {
                                k.recipientsResponses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BlobRecipients);
                            }
                            k.ClassKeys = new List <string>();
                            if (k.addressees != null)
                            {
                                foreach (Address classitem in k.addressees)
                                {
                                    if (classitem.isGroup && classitem.principal.name != null)
                                    {
                                        var reg = new Regex(@"^Class");
                                        k.ClassKeys.Add(reg.Replace(classitem.principal.name, string.Empty).Trim());
                                    }
                                }
                            }
                        }
                        catch
                        {
                            //errored out
                        }
                        fullTasks.Add(k);
                    }
                }
            }
            else if (teacher == "")
            {
                Console.WriteLine("running simple class check " + result.Count());
                foreach (var item in result)
                {
                    Address[] addresses = new Address[0];
                    try
                    {
                        if (item.BlobAddressees != null)
                        {
                            addresses = JsonConvert.DeserializeObject <Address[]>(item.BlobAddressees);
                        }
                    }
                    catch
                    {
                        //do nothing
                        addresses = new Address[0];
                    }

                    List <string> classkeys = new List <string>();
                    foreach (Address classitem in addresses)
                    {
                        if (classitem.isGroup && classitem.principal.name != null)
                        {
                            var reg = new Regex(@"^Class");
                            classkeys.Add(reg.Replace(classitem.principal.name, string.Empty).Trim());
                        }
                    }

                    if (item.id.ToString().Contains(id))
                    {
                        bool HasClass = false;
                        foreach (string clss in classkeys)
                        {
                            if (clss.ToLower().Contains(classcriteria))
                            {
                                HasClass = true;
                                break;
                            }
                        }
                        if (HasClass == false)
                        {
                            //Omit result
                            continue;
                        }

                        FullTask k = item;
                        k.ClassKeys  = classkeys;
                        k.addressees = addresses;
                        try
                        {
                            if (k.BlobPrincipal != null)
                            {
                                k.setter = JsonConvert.DeserializeObject <Principal>(k.BlobPrincipal);
                            }
                            if (k.BlobCoowner != null)
                            {
                                k.coowners = JsonConvert.DeserializeObject <Principal[]>(k.BlobCoowner);
                            }
                            if (k.BlobRecipientStatuses != null)
                            {
                                k.recipientStatuses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BlobRecipientStatuses);
                            }
                            if (k.BloballRecipients != null)
                            {
                                k.allRecipientsResponses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BloballRecipients);
                            }
                            if (k.BlobDescription != null)
                            {
                                k.descriptionDetails = JsonConvert.DeserializeObject <DescriptionDetails>(k.BlobDescription);
                            }
                            if (k.BlobFileAttachment != null)
                            {
                                k.fileAttachments = JsonConvert.DeserializeObject <FileAttachments[]>(k.BlobFileAttachment);
                            }
                            if (k.BlobPageAttachment != null)
                            {
                                k.pageAttachments = JsonConvert.DeserializeObject <PageAttachments[]>(k.BlobPageAttachment);
                            }
                            if (k.BlobRecipients != null)
                            {
                                k.recipientsResponses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BlobRecipients);
                            }
                        }
                        catch
                        {
                            //errored out
                        }
                        fullTasks.Add(k);
                    }
                }
            }
            else if (classcriteria == "")
            {
                foreach (var item in result)
                {
                    Principal tt = new Principal();
                    try
                    {
                        if (item.BlobPrincipal != null)
                        {
                            tt = JsonConvert.DeserializeObject <Principal>(item.BlobPrincipal);
                        }
                    }
                    catch
                    {
                        //do nothing
                    }

                    if (tt.name != null && tt.name.ToLower().Contains(teacher) && item.id.ToString().Contains(id))
                    {
                        FullTask k = item;
                        try
                        {
                            if (k.BlobPrincipal != null)
                            {
                                k.setter = JsonConvert.DeserializeObject <Principal>(k.BlobPrincipal);
                            }
                            if (k.BlobAddressees != null)
                            {
                                k.addressees = JsonConvert.DeserializeObject <Address[]>(k.BlobAddressees);
                            }
                            if (k.BlobCoowner != null)
                            {
                                k.coowners = JsonConvert.DeserializeObject <Principal[]>(k.BlobCoowner);
                            }
                            if (k.BlobRecipientStatuses != null)
                            {
                                k.recipientStatuses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BlobRecipientStatuses);
                            }
                            if (k.BloballRecipients != null)
                            {
                                k.allRecipientsResponses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BloballRecipients);
                            }
                            if (k.BlobDescription != null)
                            {
                                k.descriptionDetails = JsonConvert.DeserializeObject <DescriptionDetails>(k.BlobDescription);
                            }
                            if (k.BlobFileAttachment != null)
                            {
                                k.fileAttachments = JsonConvert.DeserializeObject <FileAttachments[]>(k.BlobFileAttachment);
                            }
                            if (k.BlobPageAttachment != null)
                            {
                                k.pageAttachments = JsonConvert.DeserializeObject <PageAttachments[]>(k.BlobPageAttachment);
                            }
                            if (k.BlobRecipients != null)
                            {
                                k.recipientsResponses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BlobRecipients);
                            }
                            k.ClassKeys = new List <string>();
                            if (k.addressees != null)
                            {
                                foreach (Address classitem in k.addressees)
                                {
                                    if (classitem.isGroup && classitem.principal.name != null)
                                    {
                                        var reg = new Regex(@"^Class");
                                        k.ClassKeys.Add(reg.Replace(classitem.principal.name, string.Empty).Trim());
                                    }
                                }
                            }
                        }
                        catch
                        {
                            //errored out
                        }
                        fullTasks.Add(k);
                    }
                }
            }
            else
            {
                foreach (var item in result)
                {
                    Address[] addresses = new Address[0];
                    try
                    {
                        if (item.BlobAddressees != null)
                        {
                            addresses = JsonConvert.DeserializeObject <Address[]>(item.BlobAddressees);
                        }
                    }
                    catch
                    {
                        //do nothing
                        addresses = new Address[0];
                    }

                    Principal tt = new Principal();
                    try
                    {
                        if (item.BlobPrincipal != null)
                        {
                            tt = JsonConvert.DeserializeObject <Principal>(item.BlobPrincipal);
                        }
                    }
                    catch
                    {
                        //do nothing
                    }

                    List <string> ClassKeys = new List <string>();

                    foreach (Address classitem in addresses)
                    {
                        if (classitem.isGroup && classitem.principal.name != null)
                        {
                            var reg = new Regex(@"^Class");
                            ClassKeys.Add(reg.Replace(classitem.principal.name, string.Empty).Trim());
                        }
                    }

                    if (tt.name != null && tt.name.ToLower().Contains(teacher) && item.id.ToString().Contains(id))
                    {
                        bool HasClass = false;
                        foreach (string clss in ClassKeys)
                        {
                            if (clss.ToLower().Contains(classcriteria))
                            {
                                HasClass = true;
                                break;
                            }
                        }
                        if (HasClass == false)
                        {
                            //Omit result
                            continue;
                        }

                        FullTask k = item;
                        k.ClassKeys  = ClassKeys;
                        k.addressees = addresses;
                        try
                        {
                            k.setter = tt;
                            if (k.BlobAddressees != null)
                            {
                                k.addressees = JsonConvert.DeserializeObject <Address[]>(k.BlobAddressees);
                            }
                            if (k.BlobCoowner != null)
                            {
                                k.coowners = JsonConvert.DeserializeObject <Principal[]>(k.BlobCoowner);
                            }
                            if (k.BlobRecipientStatuses != null)
                            {
                                k.recipientStatuses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BlobRecipientStatuses);
                            }
                            if (k.BloballRecipients != null)
                            {
                                k.allRecipientsResponses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BloballRecipients);
                            }
                            if (k.BlobDescription != null)
                            {
                                k.descriptionDetails = JsonConvert.DeserializeObject <DescriptionDetails>(k.BlobDescription);
                            }
                            if (k.BlobFileAttachment != null)
                            {
                                k.fileAttachments = JsonConvert.DeserializeObject <FileAttachments[]>(k.BlobFileAttachment);
                            }
                            if (k.BlobPageAttachment != null)
                            {
                                k.pageAttachments = JsonConvert.DeserializeObject <PageAttachments[]>(k.BlobPageAttachment);
                            }
                            if (k.BlobRecipients != null)
                            {
                                k.recipientsResponses = JsonConvert.DeserializeObject <RecipientResponse[]>(k.BlobRecipients);
                            }
                        }
                        catch
                        {
                            //errored out
                        }
                        fullTasks.Add(k);
                    }
                }
            }

            return(fullTasks);

            //pv.title.ToLower().Contains(criteria) &&
            //pv.setter.name.ToLower().Contains(teacher) &&
            //pv.id.ToString().Contains(id)
        }