コード例 #1
0
ファイル: CreateTask.cs プロジェクト: Helexyastis/Aufgaben
        private void SaveNewTask()
        {
            string name = tb_taskname.Text;

            if (String.IsNullOrEmpty(name))
            {
                MessageBox.Show("Name darf nicht leer sein!");
                return;
            }
            string   aufnr      = tb_aufnr.Text;
            string   kontakt    = tb_contact.Text;
            DateTime startDatum = dtp_startdatum.Value.Date;
            DateTime endDatum   = dtp_enddatum.Value.Date;
            string   status     = cb_state.SelectedText;
            string   parentName = "";

            if (!cb_isParent.Checked)
            {
                parentName = cb_parenttask.SelectedItem.ToString();
            }
            Aufgabe parent = null;

            if (!cb_isParent.Checked)
            {
                parent = manager.GetAufgabeByName(parentName);
            }

            Aufgabe aufgabe = new Aufgabe(name, parent, kontakt, status, startDatum, endDatum, aufnr, tb_beschreibung.Text);

            aufgabe.ID = AufgabenManager.ID;
            manager.SaveNewTasks(aufgabe);
        }
コード例 #2
0
        public void SaveNewTasks(Aufgabe task)
        {
            XmlNode root      = document.SelectSingleNode("aufgaben");
            XmlNode nodeToAdd = document.CreateElement("aufgabe");

            nodeToAdd.Attributes.Append(document.CreateAttribute("id"));
            nodeToAdd.Attributes.Append(document.CreateAttribute("name"));
            nodeToAdd.Attributes[0].Value = task.ID.ToString();
            nodeToAdd.Attributes[1].Value = task.Name;
            nodeToAdd.AppendChild(CreateNodeWithValue("beschreibung", task.Beschreibung));
            nodeToAdd.AppendChild(CreateNodeWithValue("annahme", task.AnnahmeDatum.ToString()));
            nodeToAdd.AppendChild(CreateNodeWithValue("abgabe", task.AbgabeDatum.ToString()));
            if (task.Parent != null)
            {
                nodeToAdd.AppendChild(CreateNodeWithValue("parent", task.Parent.ID.ToString() + ";" + task.Parent.Name));
            }
            nodeToAdd.AppendChild(CreateNodeWithValue("kontakt", task.Kontakt));
            nodeToAdd.AppendChild(CreateNodeWithValue("status", task.Status));
            nodeToAdd.AppendChild(CreateNodeWithValue("zeitaufwand", task.ZeitAufwand.ToString()));
            nodeToAdd.AppendChild(document.CreateElement("subtasks"));
            foreach (Aufgabe subTask in task.ChildTasks)
            {
                XmlNode childTask = CreateNodeWithValue("subtask", task.Parent.ID.ToString() + ";" + task.Parent.Name);
                nodeToAdd.LastChild.AppendChild(childTask);
            }
            root.AppendChild(nodeToAdd);
            if (task.Parent != null)
            {
                XmlNode parentNode = document.SelectNodes("aufgaben/aufgabe").Item(task.Parent.ID);
                XmlNode subNodes   = parentNode.LastChild;
                subNodes.AppendChild(CreateNodeWithValue("subtask", task.ID.ToString() + ";" + task.Name));
            }
            document.Save(pathToXML);
        }
コード例 #3
0
ファイル: CreateTask.cs プロジェクト: Helexyastis/Aufgaben
 public CreateTask(AufgabenControl aufgabe)
 {
     this.aufgabe   = aufgabe.Task;
     aufgabeControl = aufgabe;
     bearbeiten     = true;
     InitializeComponent();
     this.Text = "Aufgabe bearbeiten";
 }
コード例 #4
0
        private void LoadAufgaben()
        {
            XmlNodeList tasks = document.SelectNodes("aufgaben/aufgabe");

            foreach (XmlNode task in tasks)
            {
                string      name    = task.Attributes[1].Value;
                int         id      = Convert.ToInt32(task.Attributes[0].Value);
                Aufgabe     aufgabe = new Aufgabe(id, name);
                XmlNodeList values  = task.ChildNodes;
                foreach (XmlNode value in values)
                {
                    switch (value.Name)
                    {
                    case "beschreibung":
                        aufgabe.Beschreibung = value.InnerText;
                        break;

                    case "annahme":
                        aufgabe.AnnahmeDatum = Convert.ToDateTime(value.InnerText);
                        break;

                    case "abgabe":
                        aufgabe.AbgabeDatum = Convert.ToDateTime(value.InnerText);
                        break;

                    case "parent":
                        aufgabe.Parent = GetAufgabeByName(value.InnerText.Split(';')[1]);
                        break;

                    case "kontakt":
                        aufgabe.Kontakt = value.InnerText;
                        break;

                    case "status":
                        aufgabe.Status = value.InnerText;
                        break;

                    case "zeitaufwand":
                        TimeSpan temp;
                        TimeSpan.TryParse(value.InnerText, out temp);
                        aufgabe.ZeitAufwand = temp;
                        break;

                    case "subtasks":

                        break;

                    default:
                        break;
                    }
                }
                aufgabe.SetZeitStatus();
                aufgaben.Add(aufgabe);
            }
            SortAufgaben("dueDate");
        }
コード例 #5
0
        public Aufgabe GetAufgabeByName(string name)
        {
            Aufgabe returnValue = aufgaben.Find(a => a.Name == name);

            if (returnValue is null)
            {
                throw new Exception("Keine Aufgabe mit dem Namen " + name + " gefunden.");
            }
            return(returnValue);
        }
コード例 #6
0
 public void SetAufgabe(Aufgabe aufgabe)
 {
     this.aufgabe       = aufgabe;
     lAufgabenText.Text = BreakTextWithLength(aufgabe.Beschreibung, 149);
     lKontakt.Text      = aufgabe.Kontakt;
     lStartDatum.Text   = aufgabe.AnnahmeDatum.ToShortDateString();
     lEndDate.Text      = aufgabe.AbgabeDatum.ToShortDateString();
     lTimeLeft.Text     = aufgabe.TimeLeft.Days.ToString() + " Tage";
     foreach (Aufgabe subTask in aufgabe.ChildTasks)
     {
         lbSubItems.Items.Add(subTask.ID.ToString() + ";" + subTask.Name);
     }
     // gbAufgabe.BackColor = aufgabe.StatusFarbe;
     //  bEdit.BackColor = Color.FromKnownColor(KnownColor.Control);
     OnChange?.Invoke(this, new EventArgs());
 }
コード例 #7
0
 public Aufgabe(string name, Aufgabe parent, string kontakt, string status, DateTime annahme, DateTime abgabe, string aufnr, string beschreibung)
 {
     ChildTasks        = new List <Aufgabe>();
     this.name         = name;
     this.parent       = parent;
     this.kontakt      = kontakt;
     this.status       = status;
     this.annahme      = annahme;
     this.abgabe       = abgabe;
     this.aufnr        = aufnr;
     this.beschreibung = beschreibung;
     timeLeft          = abgabe.Subtract(annahme);
     SetZeitStatus();
     if (parent != null)
     {
         if (Parent.ChildTasks != null)
         {
             parent.ChildTasks.Add(this);
         }
     }
 }
コード例 #8
0
        public void SaveChangesInTask(Aufgabe aufgabe)
        {
            XmlNode aufgabenNode = GetAufgabenNode(aufgabe.Name, aufgabe.ID);

            foreach (XmlNode subNode in aufgabenNode.ChildNodes)
            {
                switch (subNode.Name)
                {
                case "beschreibung":
                    subNode.InnerText = aufgabe.Beschreibung;
                    break;

                case "annahme":
                    subNode.InnerText = aufgabe.AnnahmeDatum.ToShortDateString();
                    break;

                case "abgabe":
                    subNode.InnerText = aufgabe.AbgabeDatum.ToShortDateString();
                    break;

                case "parent":
                    subNode.InnerText = aufgabe.Name + ";" + aufgabe.ID.ToString();
                    break;

                case "kontakt":
                    subNode.InnerText = aufgabe.Kontakt;
                    break;

                case "status":
                    subNode.InnerText = aufgabe.Status;
                    break;

                case "zeitaufwand":
                    subNode.InnerText = aufgabe.TimeLeft.ToString();
                    break;

                case "subtasks":
                    foreach (Aufgabe childtask in aufgabe.ChildTasks)
                    {
                        bool exists = false;
                        foreach (XmlNode subtask in subNode.ChildNodes)
                        {
                            string[] values = subtask.InnerText.Split(';');
                            if (values[1] == childtask.Name)
                            {
                                subtask.InnerText = childtask.ID.ToString() + ";" + childtask.Name;
                                exists            = true;
                            }
                        }
                        if (!exists)
                        {
                            subNode.AppendChild(CreateNodeWithValue("subtask", childtask.ID.ToString() + ";" + childtask.Name));
                        }
                    }
                    break;

                default:
                    break;
                }
            }
            document.Save(pathToXML);
        }