27 files changed, 1310 insertions, 286 deletions
diff --git a/ApartmentManager/HousingWebApi/Controllers/AllResidentsController.cs b/ApartmentManager/HousingWebApi/Controllers/AllResidentsController.cs
new file mode 100644
index 0000000..046a385
--- /dev/null
+++ b/ApartmentManager/HousingWebApi/Controllers/AllResidentsController.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Web.Http;
+using System.Web.Http.Description;
+using HousingWebApi;
+
+namespace HousingWebApi.Controllers
+{
+    public class AllResidentsController : ApiController
+    {
+        private DataModel db = new DataModel();
+
+        // GET: api/AllResidents
+        public IQueryable<AllResident> GetAllResidents()
+        {
+            return db.AllResidents;
+        }
+
+        // GET: api/AllResidents/5
+        [ResponseType(typeof(AllResident))]
+        public IHttpActionResult GetAllResident(string id)
+        {
+            AllResident allResident = db.AllResidents.Find(id);
+            if (allResident == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(allResident);
+        }
+
+        // PUT: api/AllResidents/5
+        [ResponseType(typeof(void))]
+        public IHttpActionResult PutAllResident(string id, AllResident allResident)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != allResident.FirstName)
+            {
+                return BadRequest();
+            }
+
+            db.Entry(allResident).State = EntityState.Modified;
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!AllResidentExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return StatusCode(HttpStatusCode.NoContent);
+        }
+
+        // POST: api/AllResidents
+        [ResponseType(typeof(AllResident))]
+        public IHttpActionResult PostAllResident(AllResident allResident)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            db.AllResidents.Add(allResident);
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateException)
+            {
+                if (AllResidentExists(allResident.FirstName))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtRoute("DefaultApi", new { id = allResident.FirstName }, allResident);
+        }
+
+        // DELETE: api/AllResidents/5
+        [ResponseType(typeof(AllResident))]
+        public IHttpActionResult DeleteAllResident(string id)
+        {
+            AllResident allResident = db.AllResidents.Find(id);
+            if (allResident == null)
+            {
+                return NotFound();
+            }
+
+            db.AllResidents.Remove(allResident);
+            db.SaveChanges();
+
+            return Ok(allResident);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                db.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private bool AllResidentExists(string id)
+        {
+            return db.AllResidents.Count(e => e.FirstName == id) > 0;
+        }
+    }
+}
+\ No newline at end of file
diff --git a/ApartmentManager/HousingWebApi/Controllers/ApartmentChangesController.cs b/ApartmentManager/HousingWebApi/Controllers/ApartmentChangesController.cs
new file mode 100644
index 0000000..f96385a
--- /dev/null
+++ b/ApartmentManager/HousingWebApi/Controllers/ApartmentChangesController.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Web.Http;
+using System.Web.Http.Description;
+using HousingWebApi;
+
+namespace HousingWebApi.Controllers
+{
+    public class ApartmentChangesController : ApiController
+    {
+        private DataModel db = new DataModel();
+
+        // GET: api/ApartmentChanges
+        public IQueryable<ApartmentChange> GetApartmentChanges()
+        {
+            return db.ApartmentChanges;
+        }
+
+        // GET: api/ApartmentChanges/5
+        [ResponseType(typeof(ApartmentChange))]
+        public IHttpActionResult GetApartmentChange(int id)
+        {
+            ApartmentChange apartmentChange = db.ApartmentChanges.Find(id);
+            if (apartmentChange == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(apartmentChange);
+        }
+
+        // PUT: api/ApartmentChanges/5
+        [ResponseType(typeof(void))]
+        public IHttpActionResult PutApartmentChange(int id, ApartmentChange apartmentChange)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != apartmentChange.ChangeId)
+            {
+                return BadRequest();
+            }
+
+            db.Entry(apartmentChange).State = EntityState.Modified;
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ApartmentChangeExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return StatusCode(HttpStatusCode.NoContent);
+        }
+
+        // POST: api/ApartmentChanges
+        [ResponseType(typeof(ApartmentChange))]
+        public IHttpActionResult PostApartmentChange(ApartmentChange apartmentChange)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            db.ApartmentChanges.Add(apartmentChange);
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateException)
+            {
+                if (ApartmentChangeExists(apartmentChange.ChangeId))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtRoute("DefaultApi", new { id = apartmentChange.ChangeId }, apartmentChange);
+        }
+
+        // DELETE: api/ApartmentChanges/5
+        [ResponseType(typeof(ApartmentChange))]
+        public IHttpActionResult DeleteApartmentChange(int id)
+        {
+            ApartmentChange apartmentChange = db.ApartmentChanges.Find(id);
+            if (apartmentChange == null)
+            {
+                return NotFound();
+            }
+
+            db.ApartmentChanges.Remove(apartmentChange);
+            db.SaveChanges();
+
+            return Ok(apartmentChange);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                db.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private bool ApartmentChangeExists(int id)
+        {
+            return db.ApartmentChanges.Count(e => e.ChangeId == id) > 0;
+        }
+    }
+}
+\ No newline at end of file
diff --git a/ApartmentManager/HousingWebApi/Controllers/ApartmentResidentsController.cs b/ApartmentManager/HousingWebApi/Controllers/ApartmentResidentsController.cs
new file mode 100644
index 0000000..a754255
--- /dev/null
+++ b/ApartmentManager/HousingWebApi/Controllers/ApartmentResidentsController.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Web.Http;
+using System.Web.Http.Description;
+using HousingWebApi;
+
+namespace HousingWebApi.Controllers
+{
+    public class ApartmentResidentsController : ApiController
+    {
+        private DataModel db = new DataModel();
+
+        // GET: api/ApartmentResidents
+        public IQueryable<ApartmentResident> GetApartmentResidents()
+        {
+            return db.ApartmentResidents;
+        }
+
+        // GET: api/ApartmentResidents/5
+        [ResponseType(typeof(ApartmentResident))]
+        public IHttpActionResult GetApartmentResident(int id)
+        {
+            ApartmentResident apartmentResident = db.ApartmentResidents.Find(id);
+            if (apartmentResident == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(apartmentResident);
+        }
+
+        // PUT: api/ApartmentResidents/5
+        [ResponseType(typeof(void))]
+        public IHttpActionResult PutApartmentResident(int id, ApartmentResident apartmentResident)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != apartmentResident.ApartmentNumber)
+            {
+                return BadRequest();
+            }
+
+            db.Entry(apartmentResident).State = EntityState.Modified;
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ApartmentResidentExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return StatusCode(HttpStatusCode.NoContent);
+        }
+
+        // POST: api/ApartmentResidents
+        [ResponseType(typeof(ApartmentResident))]
+        public IHttpActionResult PostApartmentResident(ApartmentResident apartmentResident)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            db.ApartmentResidents.Add(apartmentResident);
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateException)
+            {
+                if (ApartmentResidentExists(apartmentResident.ApartmentNumber))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtRoute("DefaultApi", new { id = apartmentResident.ApartmentNumber }, apartmentResident);
+        }
+
+        // DELETE: api/ApartmentResidents/5
+        [ResponseType(typeof(ApartmentResident))]
+        public IHttpActionResult DeleteApartmentResident(int id)
+        {
+            ApartmentResident apartmentResident = db.ApartmentResidents.Find(id);
+            if (apartmentResident == null)
+            {
+                return NotFound();
+            }
+
+            db.ApartmentResidents.Remove(apartmentResident);
+            db.SaveChanges();
+
+            return Ok(apartmentResident);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                db.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private bool ApartmentResidentExists(int id)
+        {
+            return db.ApartmentResidents.Count(e => e.ApartmentNumber == id) > 0;
+        }
+    }
+}
+\ No newline at end of file
diff --git a/ApartmentManager/HousingWebApi/Controllers/ApartmentsController.cs b/ApartmentManager/HousingWebApi/Controllers/ApartmentsController.cs
index a3de905..90af553 100644
--- a/ApartmentManager/HousingWebApi/Controllers/ApartmentsController.cs
+++ b/ApartmentManager/HousingWebApi/Controllers/ApartmentsController.cs
@@ -44,7 +44,7 @@ namespace HousingWebApi.Controllers
                 return BadRequest(ModelState);
             }
 
-            if (id != apartment.ApartmentNumber)
+            if (id != apartment.ApartmentId)
             {
                 return BadRequest();
             }
@@ -87,7 +87,7 @@ namespace HousingWebApi.Controllers
             }
             catch (DbUpdateException)
             {
-                if (ApartmentExists(apartment.ApartmentNumber))
+                if (ApartmentExists(apartment.ApartmentId))
                 {
                     return Conflict();
                 }
@@ -97,7 +97,7 @@ namespace HousingWebApi.Controllers
                 }
             }
 
-            return CreatedAtRoute("DefaultApi", new { id = apartment.ApartmentNumber }, apartment);
+            return CreatedAtRoute("DefaultApi", new { id = apartment.ApartmentId }, apartment);
         }
 
         // DELETE: api/Apartments/5
@@ -127,7 +127,7 @@ namespace HousingWebApi.Controllers
 
         private bool ApartmentExists(int id)
         {
-            return db.Apartments.Count(e => e.ApartmentNumber == id) > 0;
+            return db.Apartments.Count(e => e.ApartmentId == id) > 0;
         }
     }
 }
 \ No newline at end of file
diff --git a/ApartmentManager/HousingWebApi/Controllers/ChangeCommentsController.cs b/ApartmentManager/HousingWebApi/Controllers/ChangeCommentsController.cs
new file mode 100644
index 0000000..bebff8e
--- /dev/null
+++ b/ApartmentManager/HousingWebApi/Controllers/ChangeCommentsController.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Web.Http;
+using System.Web.Http.Description;
+using HousingWebApi;
+
+namespace HousingWebApi.Controllers
+{
+    public class ChangeCommentsController : ApiController
+    {
+        private DataModel db = new DataModel();
+
+        // GET: api/ChangeComments
+        public IQueryable<ChangeComment> GetChangeComments()
+        {
+            return db.ChangeComments;
+        }
+
+        // GET: api/ChangeComments/5
+        [ResponseType(typeof(ChangeComment))]
+        public IHttpActionResult GetChangeComment(int id)
+        {
+            ChangeComment changeComment = db.ChangeComments.Find(id);
+            if (changeComment == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(changeComment);
+        }
+
+        // PUT: api/ChangeComments/5
+        [ResponseType(typeof(void))]
+        public IHttpActionResult PutChangeComment(int id, ChangeComment changeComment)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != changeComment.CommentId)
+            {
+                return BadRequest();
+            }
+
+            db.Entry(changeComment).State = EntityState.Modified;
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ChangeCommentExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return StatusCode(HttpStatusCode.NoContent);
+        }
+
+        // POST: api/ChangeComments
+        [ResponseType(typeof(ChangeComment))]
+        public IHttpActionResult PostChangeComment(ChangeComment changeComment)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            db.ChangeComments.Add(changeComment);
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateException)
+            {
+                if (ChangeCommentExists(changeComment.CommentId))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtRoute("DefaultApi", new { id = changeComment.CommentId }, changeComment);
+        }
+
+        // DELETE: api/ChangeComments/5
+        [ResponseType(typeof(ChangeComment))]
+        public IHttpActionResult DeleteChangeComment(int id)
+        {
+            ChangeComment changeComment = db.ChangeComments.Find(id);
+            if (changeComment == null)
+            {
+                return NotFound();
+            }
+
+            db.ChangeComments.Remove(changeComment);
+            db.SaveChanges();
+
+            return Ok(changeComment);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                db.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private bool ChangeCommentExists(int id)
+        {
+            return db.ChangeComments.Count(e => e.CommentId == id) > 0;
+        }
+    }
+}
+\ No newline at end of file
diff --git a/ApartmentManager/HousingWebApi/Controllers/ChangeDocumentsController.cs b/ApartmentManager/HousingWebApi/Controllers/ChangeDocumentsController.cs
new file mode 100644
index 0000000..406ab33
--- /dev/null
+++ b/ApartmentManager/HousingWebApi/Controllers/ChangeDocumentsController.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Web.Http;
+using System.Web.Http.Description;
+using HousingWebApi;
+
+namespace HousingWebApi.Controllers
+{
+    public class ChangeDocumentsController : ApiController
+    {
+        private DataModel db = new DataModel();
+
+        // GET: api/ChangeDocuments
+        public IQueryable<ChangeDocument> GetChangeDocuments()
+        {
+            return db.ChangeDocuments;
+        }
+
+        // GET: api/ChangeDocuments/5
+        [ResponseType(typeof(ChangeDocument))]
+        public IHttpActionResult GetChangeDocument(int id)
+        {
+            ChangeDocument changeDocument = db.ChangeDocuments.Find(id);
+            if (changeDocument == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(changeDocument);
+        }
+
+        // PUT: api/ChangeDocuments/5
+        [ResponseType(typeof(void))]
+        public IHttpActionResult PutChangeDocument(int id, ChangeDocument changeDocument)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != changeDocument.DocumentId)
+            {
+                return BadRequest();
+            }
+
+            db.Entry(changeDocument).State = EntityState.Modified;
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ChangeDocumentExists(id))
+                {
+                    return NotFound();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return StatusCode(HttpStatusCode.NoContent);
+        }
+
+        // POST: api/ChangeDocuments
+        [ResponseType(typeof(ChangeDocument))]
+        public IHttpActionResult PostChangeDocument(ChangeDocument changeDocument)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            db.ChangeDocuments.Add(changeDocument);
+
+            try
+            {
+                db.SaveChanges();
+            }
+            catch (DbUpdateException)
+            {
+                if (ChangeDocumentExists(changeDocument.DocumentId))
+                {
+                    return Conflict();
+                }
+                else
+                {
+                    throw;
+                }
+            }
+
+            return CreatedAtRoute("DefaultApi", new { id = changeDocument.DocumentId }, changeDocument);
+        }
+
+        // DELETE: api/ChangeDocuments/5
+        [ResponseType(typeof(ChangeDocument))]
+        public IHttpActionResult DeleteChangeDocument(int id)
+        {
+            ChangeDocument changeDocument = db.ChangeDocuments.Find(id);
+            if (changeDocument == null)
+            {
+                return NotFound();
+            }
+
+            db.ChangeDocuments.Remove(changeDocument);
+            db.SaveChanges();
+
+            return Ok(changeDocument);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                db.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private bool ChangeDocumentExists(int id)
+        {
+            return db.ChangeDocuments.Count(e => e.DocumentId == id) > 0;
+        }
+    }
+}
+\ No newline at end of file
diff --git a/ApartmentManager/HousingWebApi/Controllers/PastContractOwnersController.cs b/ApartmentManager/HousingWebApi/Controllers/DefectCommentsController.cs
index d1f3e00..ae5222d 100644
--- a/ApartmentManager/HousingWebApi/Controllers/PastContractOwnersController.cs
+++ b/ApartmentManager/HousingWebApi/Controllers/DefectCommentsController.cs
@@ -12,44 +12,44 @@ using HousingWebApi;
 
 namespace HousingWebApi.Controllers
 {
-    public class PastContractOwnersController : ApiController
+    public class DefectCommentsController : ApiController
     {
         private DataModel db = new DataModel();
 
-        // GET: api/PastContractOwners
-        public IQueryable<PastContractOwner> GetPastContractOwners()
+        // GET: api/DefectComments
+        public IQueryable<DefectComment> GetDefectComments()
         {
-            return db.PastContractOwners;
+            return db.DefectComments;
         }
 
-        // GET: api/PastContractOwners/5
-        [ResponseType(typeof(PastContractOwner))]
-        public IHttpActionResult GetPastContractOwner(int id)
+        // GET: api/DefectComments/5
+        [ResponseType(typeof(DefectComment))]
+        public IHttpActionResult GetDefectComment(int id)
         {
-            PastContractOwner pastContractOwner = db.PastContractOwners.Find(id);
-            if (pastContractOwner == null)
+            DefectComment defectComment = db.DefectComments.Find(id);
+            if (defectComment == null)
             {
                 return NotFound();
             }
 
-            return Ok(pastContractOwner);
+            return Ok(defectComment);
         }
 
-        // PUT: api/PastContractOwners/5
+        // PUT: api/DefectComments/5
         [ResponseType(typeof(void))]
-        public IHttpActionResult PutPastContractOwner(int id, PastContractOwner pastContractOwner)
+        public IHttpActionResult PutDefectComment(int id, DefectComment defectComment)
         {
             if (!ModelState.IsValid)
             {
                 return BadRequest(ModelState);
             }
 
-            if (id != pastContractOwner.Id)
+            if (id != defectComment.PictureId)
             {
                 return BadRequest();
             }
 
-            db.Entry(pastContractOwner).State = EntityState.Modified;
+            db.Entry(defectComment).State = EntityState.Modified;
 
             try
             {
@@ -57,7 +57,7 @@ namespace HousingWebApi.Controllers
             }
             catch (DbUpdateConcurrencyException)
             {
-                if (!PastContractOwnerExists(id))
+                if (!DefectCommentExists(id))
                 {
                     return NotFound();
                 }
@@ -70,16 +70,16 @@ namespace HousingWebApi.Controllers
             return StatusCode(HttpStatusCode.NoContent);
         }
 
-        // POST: api/PastContractOwners
-        [ResponseType(typeof(PastContractOwner))]
-        public IHttpActionResult PostPastContractOwner(PastContractOwner pastContractOwner)
+        // POST: api/DefectComments
+        [ResponseType(typeof(DefectComment))]
+        public IHttpActionResult PostDefectComment(DefectComment defectComment)
         {
             if (!ModelState.IsValid)
             {
                 return BadRequest(ModelState);
             }
 
-            db.PastContractOwners.Add(pastContractOwner);
+            db.DefectComments.Add(defectComment);
 
             try
             {
@@ -87,7 +87,7 @@ namespace HousingWebApi.Controllers
             }
             catch (DbUpdateException)
             {
-                if (PastContractOwnerExists(pastContractOwner.Id))
+                if (DefectCommentExists(defectComment.PictureId))
                 {
                     return Conflict();
                 }
@@ -97,23 +97,23 @@ namespace HousingWebApi.Controllers
                 }
             }
 
-            return CreatedAtRoute("DefaultApi", new { id = pastContractOwner.Id }, pastContractOwner);
+            return CreatedAtRoute("DefaultApi", new { id = defectComment.PictureId }, defectComment);
         }
 
-        // DELETE: api/PastContractOwners/5
-        [ResponseType(typeof(PastContractOwner))]
-        public IHttpActionResult DeletePastContractOwner(int id)
+        // DELETE: api/DefectComments/5
+        [ResponseType(typeof(DefectComment))]
+        public IHttpActionResult DeleteDefectComment(int id)
         {
-            PastContractOwner pastContractOwner = db.PastContractOwners.Find(id);
-            if (pastContractOwner == null)
+            DefectComment defectComment = db.DefectComments.Find(id);
+            if (defectCommen