public AgendaItem Create(AgendaItem item)
{
_db.AgendaItems.Add(item);
_db.SaveChanges();
return(item);
}
public async Task AddAsync(AgendaItem agendaItem)
{
_context.AttachRange(agendaItem.Speakers);
await _agendaItems.AddAsync(agendaItem);
await _context.SaveChangesAsync();
}
private string GenerateExportAgendaContent(AgendaItem agenda)
{
string result = "(" + agenda.m_AgendaIndex.ToString() + ") " + agenda.m_Content + NEWLINE;
result += GenerateExportDetailContents(agenda);
return(result);
}
public IActionResult PutAgendaItem(int id, [FromBody] AgendaItem item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != item.Id)
{
return(BadRequest());
}
try
{
_service.Update(id, item);
}
catch (DbUpdateConcurrencyException)
{
if (!_service.AgendaItemExists(id))
{
return(NotFound());
}
else
{
throw new AppException("Update failed");
}
}
return(NoContent());
}
public async Task <int> AddAgendaItemAsync(AgendaItem agendaItem)
{
_manualResetEvent.WaitOne();
try
{
AgendaItemContext agendaItemContext = new AgendaItemContext();
agendaItem = (await agendaItemContext.AddAsync(agendaItem)).Entity;
await agendaItemContext.SaveChangesAsync();
_manualResetEvent.Set();
return(agendaItem.Id);
}
catch (Exception e)
{
if (_exceptionLogItemContext != null)
{
await AddExceptionLogItem(new ExceptionLogItem()
{
TimeStamp = DateTime.Now, Message = e.Message, Source = e.Source, StackTrace = e.StackTrace
});
}
_manualResetEvent.Set();
return(int.MinValue);
}
}
public void Update(int id, Agenda entity)
{
Agenda agenda = _db.Agendas.Where(a => a.Id == id).Include(i => i.Items).FirstOrDefault();
agenda.AgendaCategoryId = entity.AgendaCategoryId;
agenda.Description = entity.Description;
agenda.Title = entity.Title;
agenda.Status = entity.Status;
agenda.IsDeleted = entity.IsDeleted;
List <AgendaItem> deletedItems = agenda.Items.Where(i => !entity.Items.Any(i2 => i2.Id == i.Id)).ToList();
foreach (AgendaItem item in deletedItems)
{
_db.Entry(item).State = EntityState.Deleted;
}
foreach (AgendaItem item in entity.Items)
{
if (item.Id > 0)
{
AgendaItem itemToChange = agenda.Items.Single(i => i.Id == item.Id);
_db.Entry(itemToChange).CurrentValues.SetValues(item);
_db.Entry(itemToChange).State = EntityState.Modified;
}
else
{
agenda.Items.Add(item);
}
}
_db.Entry(agenda).State = EntityState.Modified;
_db.SaveChanges();
}
public AgendaItem ModifyAgendaItem(AgendaItem agendaItem)
{
StringBuilder stringBuilder = new StringBuilder();
string temp;
AgendaItem item = new AgendaItem();
using (var sr = new StreamReader(path))
{
while ((temp = sr.ReadLine()) != null)
{
if (ReturnAgendaItemFromLine(temp).Id == agendaItem.Id)
{
item.Description = agendaItem.Description;
item.Title = agendaItem.Title;
item.FinishDate = agendaItem.FinishDate;
item.Priority = agendaItem.Priority;
item.IsCompleted = agendaItem.IsCompleted;
string tempString = $"{agendaItem.Id}|{agendaItem.Title}|{agendaItem.Description}|{agendaItem.StartDate}|{agendaItem.FinishDate}|{agendaItem.IsCompleted}|{agendaItem.IsRepeatable}|{agendaItem.RepeatableInterval}|{agendaItem.Priority}";
stringBuilder.AppendLine(tempString);
}
else
{
stringBuilder.AppendLine(temp);
}
}
}
using (var sw = new StreamWriter(path))
{
sw.Write(stringBuilder);
}
return(item);
}
public AgendaItem GetAgendaItem(int _eventID)
{
AgendaItem item = null;
var query = "SELECT * FROM dbo.Events WHERE ItemID = @_eventID";
SqlCommand cmd = new SqlCommand(query, _conn);
cmd.Parameters.AddWithValue("@_eventID", _eventID);
_conn.Open();
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
int eventID = reader.GetInt32(0);
string eventName = reader.GetString(1);
string eventCat = reader.GetString(2);
DateTime eventDate = reader.GetDateTime(3);
string ShortDesc = reader.GetString(4);
string LongDesc = reader.GetString(5);
string HostName = reader.GetString(6);
string HostInfo = reader.GetString(7);
item = new AgendaItem(eventID, eventName, eventCat, eventDate.ToShortDateString(), ShortDesc, LongDesc, HostName, HostInfo, "dbtest");
}
}
_conn.Close();
return(item);
}
public async Task <IActionResult> PutAgendaItem(long id, AgendaItem agendaItem)
{
if (id != agendaItem.Id)
{
return(BadRequest());
}
_context.Entry(agendaItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AgendaItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void GenerateExportAgendaContentTest()
{
string expected = "(1) agenda1\n\t[decided]agenda1->detail1 content\n\t\t[important]agenda1->detail2 content\n";
MinutesModel model = new MinutesModel();
AgendaItem agenda = new AgendaItem(1);
agenda.m_AgendaIndex = 1;
agenda.m_Content = "agenda1";
agenda.m_DetailItems = new System.Collections.ObjectModel.ObservableCollection <DetailItem>();
DetailItem detail1 = new DetailItem();
detail1.m_ContentIndex = 1;
detail1.m_ContentIndentLevel = 1;
detail1.m_Content = "agenda1->detail1 content";
detail1.m_ContentStateType = ContentStateType.decided;
agenda.m_DetailItems.Add(detail1);
DetailItem detail2 = new DetailItem();
detail2.m_ContentIndex = 2;
detail2.m_ContentIndentLevel = 2;
detail2.m_Content = "agenda1->detail2 content";
detail2.m_ContentStateType = ContentStateType.important;
agenda.m_DetailItems.Add(detail2);
Assert.AreEqual(expected, model.AsDynamic().GenerateExportAgendaContent(agenda));
}
public async Task <IActionResult> PutAgendaItem([FromRoute] int id, [FromBody] AgendaItem agendaItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != agendaItem.AgendaItemId)
{
return(BadRequest());
}
Context.Entry(agendaItem).State = EntityState.Modified;
try
{
await Context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AgendaItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <AgendaItem> > PostAgendaItem(AgendaItem agendaItem)
{
_context.AgendaItems.Add(agendaItem);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetAgendaItem), new { id = agendaItem.Id }, agendaItem));
}
public void CreateMultipleRepeatableAgendas(AgendaItem item)
{
using (StreamWriter sw = File.AppendText(path))
{
string tempString = $"{item.Id}|{item.Title}|{item.Description}|{item.StartDate}|{item.FinishDate}|{item.IsCompleted}|{item.IsRepeatable}|{item.RepeatableInterval}|{item.Priority}";
sw.WriteLine(tempString);
}
}
public void Update(int id, AgendaItem entity)
{
AgendaItem item = _db.AgendaItems.Find(id);
item.Todo = entity.Todo;
_db.Entry(item).State = EntityState.Modified;
_db.SaveChanges();
}
public virtual void CreateAgenda(AgendaItem item)
{
using (var context = new AgendaDbContext())
{
context.AgendaItems.Add(item);
context.SaveChanges();
}
}
public IActionResult DeleteAgendaItem(int id)
{
AgendaItem item = _service.Delete(id);
if (item == null)
{
return(NotFound());
}
return(Ok(item));
}
public IActionResult PostAgendaItem([FromBody] AgendaItem entity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
AgendaItem item = _service.Create(entity);
return(Ok(item));
}
public void SendVotableItems()
{
if (!Player.instance.IsDecider)
{
for (int i = 0; i < myItems.Length; i++)
{
AgendaItem item = myItems[i];
MessageSender.instance.SendMessageToAll("ReceiveVotableItems", item.playerName, item.description, item.bonus);
}
}
}
public void CancelAdd_Click(object sender, RoutedEventArgs e)
{
if (State == PageState.MinWidth700)
{
AgendaItem = new AgendaItem();
}
else
{
NavigationService.Navigate <InitialPage>();
}
}
public IActionResult GetAgendaItem(int id)
{
AgendaItem item = _service.GetById(id);
if (item == null)
{
return(NotFound());
}
return(Ok(item));
}
public override void OnScreenStart(bool hosting, bool isDecider)
{
AgendaItemsManager aiManager = AgendaItemsManager.instance;
currentItem = aiManager.NextItem;
if (currentItem == null)
{
GotoScreen("Agenda Results");
return;
}
progress.Content = string.Format("{0} / {1}", aiManager.CurrentIndex, aiManager.TotalItems);
description.Content = Copy.AgendaItemVote(Player.instance.WinningPlayer, currentItem.description);
}
public ActionResult GetAgendaItem(int topicID, string instanceID)
{
var agIt = new AgendaItem
{
ID = topicID,
Name = "TODO: Name for #" + topicID.ToString(),
InstanceID = instanceID
};
//var room = Repository.GetRooms().Where(r => r.ID == roomID).Single();
return PartialView("_AgendaItem", agIt);
}
public void AddAgendaItem_Click(object sender, RoutedEventArgs e)
{
CanDelete = Visibility.Collapsed;
if (State == PageState.MinWidth700)
{
AgendaItem = new AgendaItem();
}
else
{
NavigationService.Navigate <AddAgendaItem>(new AgendaItem());
}
}
public AgendaItem Delete(int id)
{
AgendaItem item = _db.AgendaItems.Find(id);
if (item == null)
{
return(null);
}
_db.AgendaItems.Remove(item);
_db.SaveChanges();
return(item);
}
private int GetNewestAgendaId()
{
var client = new MongoClient(connectionString);
var database = client.GetDatabase("Develop");
var collection = database.GetCollection <BsonDocument>("agendas");
var sort = Builders <BsonDocument> .Sort.Descending("_id");
var s = collection.Find(new BsonDocument()).Sort(sort).FirstOrDefault().ToString();
AgendaItem i = JsonConvert.DeserializeObject <AgendaItem>(s);
return(i.Id);
}
private string GenerateExportDetailContents(AgendaItem agenda)
{
if (agenda.m_DetailItems == null)
{
return("");
}
string result = "";
foreach (DetailItem detail in agenda.m_DetailItems)
{
result += GenerateExportDetailContent(detail);
}
return(result);
}
public AgendaItemWindow(AgendaItem agenda, string translationLanguage)
{
agendaManager = new AgendaManagerCSV();
uiMessagesService = new UiMessagesService(translationLanguage);
agendaItem = new AgendaItem();
InitializeComponent();
agendaItem = agenda;
lblAgendaItemTitle.Content = agenda.Title;
lblAgendaItemDescription.Content = agenda.Description;
TranslateWindowText();
}
public async Task <IActionResult> PostAgendaItem([FromBody] AgendaItem agendaItem)
{
var AlreadyExists = Context.Items.Where(x => x.AgendaItemId == agendaItem.AgendaItemId).Count();
if (!ModelState.IsValid || AlreadyExists != 0)
{
return(BadRequest(ModelState));
}
Context.Items.Add(agendaItem);
await Context.SaveChangesAsync();
return(CreatedAtAction("GetAgendaItem", new { id = agendaItem.AgendaItemId }, agendaItem));
}
public void TestCreateAnAgendaItem()
{
var session = _context.CommitteeSessions.FirstOrDefault(n => n.Committee.CommitteeId == "munsh22-gv");
Assert.NotNull(session);
var agendaItem = new AgendaItem()
{
Name = "Test Tagesordnungspunkt"
};
session.CurrentAgendaItem = agendaItem;
_context.SaveChanges();
Assert.NotNull(_context.CommitteeSessions.Include(n => n.CurrentAgendaItem).FirstOrDefault(n => n.Committee.CommitteeId == "munsh22-gv").CurrentAgendaItem);
}
Role CreateRole(JSONNode node)
{
Role r = new Role(node["name"], node["bio"]);
JSONArray jsonItems = node["agenda_items"] as JSONArray;
AgendaItem[] items = new AgendaItem[jsonItems.Count];
for (int i = 0; i < jsonItems.Count; i++)
{
items[i] = new AgendaItem(Player.instance.Name, jsonItems[i]["description"], Int32.Parse(jsonItems[i]["bonus"]));
}
r.SetAgendaItems(items);
return(r);
}
public List <AgendaItem> ConvertTherapyToAcceptedAgendaItems(List <Therapy> therapies)
{
List <AgendaItem> agendaItems = new List <AgendaItem>();
foreach (var therapy in therapies)
{
if (therapy.Accepted)
{
AgendaItem agendaItem = new AgendaItem();
agendaItem.Description = (therapy.Time.ToString("h'h 'm'm 's's'")) + " <br/>" + (therapy.description ?? "") + ("<br/>" + therapy.Location ?? "") + ("<br/>Behandelaar: " + therapy.therapistFirstName ?? "") + (" " + therapy.therapistLastName ?? "");
agendaItem.StartTime = therapy.date;
agendaItem.EndTime = therapy.date + therapy.Time;
agendaItem.ID = therapy.ID;
agendaItems.Add(agendaItem);
}
}
return(agendaItems);
}
private MetaDataDataCollection ParseDocumentItems(XmlNode documentItemsNode)
{
MetaDataDataCollection metaCollection = new MetaDataDataCollection();
foreach (XmlNode documentItemNode in documentItemsNode.ChildNodes)
{
// process basic MetaDataData properties
MetaDataData meta = new MetaDataData();
meta.Name = documentItemNode.SelectSingleNode("Name").InnerText;
meta.ForeignID = Int32.Parse(documentItemNode.SelectSingleNode("ForeignID").InnerText);
meta.Consent = Int32.Parse(documentItemNode.SelectSingleNode("Consent").InnerText);
// process payload
switch (documentItemNode.Name)
{
case "AgendaItem":
AgendaItem agendaItem = new AgendaItem();
agendaItem.Actions = documentItemNode.SelectSingleNode("Actions").InnerText;
agendaItem.Department = documentItemNode.SelectSingleNode("Department").InnerText;
meta.Payload = agendaItem;
break;
case "Note":
Note note = new Note();
note.NoteText = documentItemNode.SelectSingleNode("NoteText").InnerText;
note.EditorsNotes = documentItemNode.SelectSingleNode("EditorsNotes").InnerText;
note.Private = bool.Parse(documentItemNode.SelectSingleNode("Private").InnerText);
meta.Payload = note;
break;
case "Document":
Document doc = new Document();
doc.Description = documentItemNode.SelectSingleNode("Description").InnerText;
doc.Location = documentItemNode.SelectSingleNode("Location").InnerText;
meta.Payload = doc;
break;
default:
// this isn't payload type we are interested in loading, just skip it
continue;
}
// recursively process any child nodes
meta.Children = ParseDocumentItems(documentItemNode.SelectSingleNode("Children"));
metaCollection.Add(meta);
}
return metaCollection;
}
