public async Task <ActionResult> NewPage(string username, NewPageModel model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var user = db.User.FirstOrDefault(u => u.Username.Equals(username));
var newPage = db.Page.Create();
newPage.name = model.PageTitle;
if (Request["PrivacyDropDown"].Any())
{
var privSel = Request["PrivacyDropDown"];
var privacy = Convert.ToInt32(privSel);
newPage.IDprivacy = privacy;
}
else
{
return(RedirectToAction("NewPage", new { Username = username }));
}
newPage.CreatedAt = DateTime.Now;
newPage.PageView = 0;
db.Page.Add(newPage);
db.SaveChanges();
var newContributor = db.Contributor.Create();
newContributor.IDpage = newPage.IDpage;
newContributor.IDuser = user.IDuser;
newContributor.IsAuthor = true;
db.Contributor.Add(newContributor);
db.SaveChanges();
return(RedirectToAction("Index", new { Username = username }));
}
}
public async Task <ActionResult> ViewDetails(int IDpage, string username, PageDetailModel model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var currentUser = User.Identity.GetUserName();
var user = db.User.FirstOrDefault(u => u.Username.Equals(username));
var current = db.User.FirstOrDefault(u => u.Username.Equals(currentUser));
var reviewExists = (from p in db.PageReview
where p.IDpage == IDpage &&
p.IDreviewer == current.IDuser
select p).ToList();
if (reviewExists.Any())
{
var selReview = db.PageReview.Find(IDpage, current.IDuser);
selReview.Mark = model.Grade;
db.Entry(selReview).State = EntityState.Modified;
db.SaveChanges();
}
if (!reviewExists.Any())
{
var selReview = db.PageReview.Create();
selReview.IDpage = IDpage;
selReview.IDreviewer = current.IDuser;
selReview.Mark = model.Grade;
db.PageReview.Add(selReview);
db.SaveChanges();
}
}
return(RedirectToAction("Details", new { IDpage = IDpage, Username = username }));
}
public async Task <ActionResult> Add(AddNewGroupModel model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var username = User.Identity.GetUserName();
var user = db.User.FirstOrDefault(u => u.Username.Equals(username));
var newGroup = db.Group.Create();
if (Request["GroupTypeDropDown"].Any())
{
var groupTypeSel = Request["GroupTypeDropDown"];
var gt = Convert.ToInt32(groupTypeSel);
newGroup.IDgroupType = gt;
}
newGroup.Name = model.Name;
newGroup.IDgroupOwner = user.IDuser;
db.Group.Add(newGroup);
db.SaveChanges();
var authorToGroup = db.BelongsToGroup.Create();
authorToGroup.IDgroup = newGroup.IDgroup;
authorToGroup.IDuser = user.IDuser;
authorToGroup.TimeChanged = DateTime.Now;
db.BelongsToGroup.Add(authorToGroup);
db.SaveChanges();
return(RedirectToAction("Index", "Group"));
}
}
public async Task <ActionResult> Edit(UserEditModel model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
if (ModelState.IsValid)
{
string username = User.Identity.GetUserName();
// Get the userprofile
User user = db.User.FirstOrDefault(u => u.Username.Equals(username));
// Update fields
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Email = model.Email;
if (Request["CityDropDown"].Any())
{
var citySel = Request["CityDropDown"];
user.IDcityFrom = Convert.ToInt32(citySel);
}
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", "Home")); // or whatever
}
return(View(model));
}
}
public async Task <ActionResult> ShowDetails(int IDcontent, string username, ContentDetails model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var currentUser = User.Identity.GetUserName();
var cont = db.Content.FirstOrDefault(u => u.IDcontent.Equals(IDcontent));
var usernameAuthor = db.User.FirstOrDefault(u => u.IDuser.Equals(cont.IDauthor));
var usernameCurrent = db.User.FirstOrDefault(u => u.Username.Equals(currentUser));
if (Request["PageDropDown"].Any())
{
var contCopy = db.Content.Create();
contCopy.IDcontentType = cont.IDcontentType;
contCopy.IDauthor = usernameCurrent.IDuser;
contCopy.Text = cont.Text;
contCopy.Title = cont.Title;
contCopy.IsCopied = true;
contCopy.IDeditor = usernameCurrent.IDuser;
contCopy.TimeChanged = DateTime.Now;
db.Content.Add(contCopy);
db.SaveChanges();
var contCopyLoc = (from l in db.LocationContent
where l.IDcontent == cont.IDcontent
select l.IDlocation).ToList();
foreach (var a in contCopyLoc)
{
var contLoc = db.LocationContent.Create();
contLoc.IDlocation = a;
contLoc.IDcontent = contCopy.IDcontent;
contLoc.TimeChanged = DateTime.Now;
db.LocationContent.Add(contLoc);
db.SaveChanges();
}
var contPage = db.ContentPage.Create();
contPage.IDcontent = contCopy.IDcontent;
contPage.IDuser = usernameCurrent.IDuser;
var pageSel = Request["PageDropDown"];
contPage.IDpage = Convert.ToInt32(pageSel);
db.ContentPage.Add(contPage);
db.SaveChanges();
}
}
return(RedirectToAction("Details", new { IDcontent = IDcontent, Username = username }));
}
public async Task <ActionResult> DeleteContentConfirm(int IDpage, int IDcontent, string username)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var contentDelete = db.ContentPage.Find(IDcontent, IDpage);
db.ContentPage.Remove(contentDelete);
db.SaveChanges();
}
return(RedirectToAction("Details", new { IDpage = IDpage }));
}
public async Task <ActionResult> DeletePage(int IDpage, string username)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var page = db.Page.FirstOrDefault(u => u.IDpage.Equals(IDpage));
var pageDelete = db.Page.Find(IDpage);
db.Page.Remove(pageDelete);
db.SaveChanges();
}
return(RedirectToAction("Index", new { Username = username }));
}
public async Task <ActionResult> DeleteConfirm(int IDcontent, string username)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var cont = db.Content.FirstOrDefault(u => u.IDcontent.Equals(IDcontent));
var contentDelete = db.Content.Find(IDcontent);
db.Content.Remove(contentDelete);
db.SaveChanges();
}
return(RedirectToAction("ViewContent", new { Username = username }));
}
public ActionResult DeleteContributor(int IDpage, int IDuser, string username)
{
UsernameModel model = new UsernameModel();
model.Username = username;
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var contributorDelete = db.Contributor.Find(IDpage, IDuser);
db.Contributor.Remove(contributorDelete);
db.SaveChanges();
}
return(RedirectToAction("Edit", new { IDpage = IDpage, Username = username }));
}
public ActionResult DeleteTag(int IDpage, int IDtag, string username)
{
UsernameModel model = new UsernameModel();
model.Username = username;
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var tagDelete = db.PageTag.Find(IDtag, IDpage);
db.PageTag.Remove(tagDelete);
db.SaveChanges();
}
return(RedirectToAction("Edit", new { IDpage = IDpage, Username = username }));
}
public ActionResult DeleteLocation(int IDlocation, int IDcontent, string username)
{
UsernameModel model = new UsernameModel();
model.Username = username;
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var deleteLocationContent = db.LocationContent.Find(IDlocation, IDcontent);
db.LocationContent.Remove(deleteLocationContent);
db.SaveChanges();
}
return(RedirectToAction("Edit", new { IDcontent = IDcontent, Username = username }));
}
public async Task <ActionResult> DeleteConfirm(int IDgroup)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
if (IDgroup == 1)
{
return(RedirectToAction("Index", "Group"));
}
var groupDelete = db.Group.Find(IDgroup);
db.Group.Remove(groupDelete);
db.SaveChanges();
}
return(RedirectToAction("Index", "Group"));
}
public async Task <ActionResult> Cities(CityCountryListModel model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
if (model.CountryName != null && model.CityName == null && Request["CountryDropDown"] == null && Request["LocationTypeDropDown"] == null)
{
var newCountry = db.Country.Create();
newCountry.CountryName = model.CountryName;
db.Country.Add(newCountry);
db.SaveChanges();
return(RedirectToAction("Cities", "Home"));
}
if (model.CountryName == null && model.CityName != null && Request["LocationTypeDropDown"] != null && Request["CountryDropDown"] != null)
{
var newCity = db.City.Create();
newCity.CityName = model.CityName;
var countrySel = Request["CountryDropDown"];
newCity.IDcountry = Convert.ToInt32(countrySel);
db.City.Add(newCity);
db.SaveChanges();
var newLocation = db.Location.Create();
newLocation.IDcity = newCity.IDcity;
var locTypeSel = Request["LocationTypeDropDown"];
newLocation.IDlocationType = Convert.ToInt32(locTypeSel);
db.Location.Add(newLocation);
db.SaveChanges();
return(RedirectToAction("Cities", "Home"));
}
}
return(RedirectToAction("Cities", "Home"));
}
public ActionResult DeleteMember(int IDgroup, int IDuser)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
if (IDgroup == 1)
{
return(RedirectToAction("Index", "Group"));
}
var groupMemberDelete = db.BelongsToGroup.Find(IDgroup, IDuser);
db.BelongsToGroup.Remove(groupMemberDelete);
db.SaveChanges();
}
return(RedirectToAction("Details", new { IDgroup = IDgroup }));
}
public ActionResult UpdateLayout(string Values, int IDpage)
{
var array = JArray.Parse(Values);
IList <Serialized> objectsList = new List <Serialized>();
foreach (var item in array)
{
objectsList.Add(item.ToObject <Serialized>());
}
var numberObjects = objectsList.Count();
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var query = (from c in db.LocationContent
join p in db.ContentPage on c.IDcontent equals p.IDcontent
where p.IDpage == IDpage
select c).Include(c => c.Content).Include(c => c.Location).Include(c => c.City).GroupBy(c => c.IDlocation).ToList();
int brojac = 0;
foreach (var el in query)
{
if (el.Count() != numberObjects)
{
continue;
}
foreach (var element in el)
{
var currentContent = db.Content.Find(element.Content.IDcontent);
currentContent.DataSizeX = objectsList[brojac].size_x;
currentContent.DataSizeY = objectsList[brojac].size_y;
currentContent.DataCol = objectsList[brojac].col;
currentContent.DataRow = objectsList[brojac].row;
db.Entry(currentContent).State = EntityState.Modified;
db.SaveChanges();
brojac++;
}
}
}
return(RedirectToAction("Details", new { IDpage = IDpage, Username = "******" }));
}
public async Task <ActionResult> Edit(int IDgroup, GroupEditDetailsModel model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
if (ModelState.IsValid)
{
var group = db.Group.Find(IDgroup);
group.Name = model.Name;
if (Request["GroupTypeDropDown"].Any())
{
var groupTypeSel = Request["GroupTypeDropDown"];
var gt = Convert.ToInt32(groupTypeSel);
group.IDgroupType = gt;
}
db.Entry(group).State = EntityState.Modified;
db.SaveChanges();
}
}
return(Content("Changes are successfully saved!", "text/html"));
//return RedirectToAction("Edit", new { IDgroup = IDgroup });
}
public async Task <ActionResult> Comments(ContentComments model, int IDcontent, int IDpage, string Username)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
if (model.UserComment == null)
{
return(Content("The comment cannot be empty!", "text/html"));
}
var user = User.Identity.GetUserName();
var userInfo = (from u in db.User
where u.Username == user
select u);
var newComment = db.ContentComment.Create();
newComment.IDcontent = IDcontent;
newComment.IDuser = userInfo.FirstOrDefault().IDuser;
newComment.Comment = model.UserComment;
newComment.Timestamp = DateTime.Now;
db.ContentComment.Add(newComment);
db.SaveChanges();
}
return(Content("The comment was successfully added!", "text/html"));
}
public ActionResult AddMember(int IDgroup)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
if (IDgroup == 1)
{
return(RedirectToAction("Index", "Group"));
}
var newGroupMember = db.BelongsToGroup.Create();
newGroupMember.IDgroup = IDgroup;
if (Request["MemberAddDropDown"].Any())
{
var memberSel = Request["MemberAddDropDown"];
var IDuser = Convert.ToInt32(memberSel);
newGroupMember.IDuser = IDuser;
}
newGroupMember.TimeChanged = DateTime.Now;
db.BelongsToGroup.Add(newGroupMember);
db.SaveChanges();
}
return(RedirectToAction("Details", new { IDgroup = IDgroup }));
}
public ActionResult Details(int IDpage, string username)
{
PageDetailModel model = new PageDetailModel();
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
List <LocationContent> query = (from c in db.LocationContent
join p in db.ContentPage on c.IDcontent equals p.IDcontent
where p.IDpage == IDpage
select c).Include(c => c.Content).Include(c => c.Location).Include(c => c.City).Include("Content.User").ToList();
model.PageContents = query;
var contributors = (from c in db.Contributor
join u in db.User on c.IDuser equals u.IDuser
where c.IDpage == IDpage &&
c.IsAuthor == false
select u).ToList();
model.Contributors = contributors;
var PageInfo = (from p in db.Page
where p.IDpage == IDpage
select p);
model.PageName = PageInfo.First().name;
model.IDpage = PageInfo.First().IDpage;
var selPage = db.Page.FirstOrDefault(u => u.IDpage.Equals(IDpage));
var pageAuthor = (from p in db.Contributor
join u in db.User on p.IDuser equals u.IDuser
where p.IDpage == IDpage &&
p.IsAuthor == true
select u);
model.PageAuthor = pageAuthor.FirstOrDefault().Username;
var views = selPage.PageView;
views++;
selPage.PageView = views;
db.Entry(selPage).State = EntityState.Modified;
db.SaveChanges();
var marksExist = (from p in db.PageReview
where p.IDpage == IDpage
select p).ToList();
if (marksExist.Any())
{
var average = (from p in db.PageReview
where p.IDpage == IDpage
select p).Average(p => p.Mark);
if (!Request.IsAuthenticated)
{
model.AverageGrade = average;
return(View(model));
}
else
{
model.Username = username;
model.AverageGrade = average;
return(View(model));
}
}
else
{
double average = 0;
if (!Request.IsAuthenticated)
{
model.AverageGrade = average;
return(View(model));
}
else
{
model.Username = username;
model.AverageGrade = average;
return(View(model));
}
}
}
}
public async Task <ActionResult> Edit(int IDcontent, string username, Contents model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var query = db.Content.FirstOrDefault(u => u.IDcontent.Equals(IDcontent));
var currentUser = User.Identity.GetUserName();
var usernameCurrent = db.User.FirstOrDefault(u => u.Username.Equals(currentUser));
if (ModelState.IsValid)
{
var user = db.User.FirstOrDefault(u => u.Username.Equals(username));
// Get the userprofile
model.Username = username;
if (model.Title != null)
{
query.Title = model.Title;
}
else
{
query.Title = "(no title)";
} query.Text = model.Text;
query.IDeditor = user.IDuser;
query.TimeChanged = DateTime.Now;
/*if (Request["PageDropDown"].Any())
* {
* var pageSel = Request["PageDropDown"];
* var page = Convert.ToInt32(pageSel);
*
* var exists = from cp in db.ContentPage
* where cp.IDpage == page
* && cp.IDcontent == IDcontent
* select cp;
* if (!exists.Any())
* {
* var newPage = db.ContentPage.Create();
* newPage.IDcontent = IDcontent;
* newPage.IDpage = Convert.ToInt32(pageSel);
* newPage.IDuser = user.IDuser;
* db.ContentPage.Add(newPage);
* db.SaveChanges();
* }
* else
* {
* return Content("The selected page already contains this content.", "text/html");
* }
* }*/
if (Request["PageDropDown"].Any())
{
var contCopy = db.Content.Create();
contCopy.IDcontentType = query.IDcontentType;
contCopy.IDauthor = usernameCurrent.IDuser;
contCopy.Text = query.Text;
contCopy.Title = query.Title;
contCopy.IsCopied = true;
db.Content.Add(contCopy);
db.SaveChanges();
var contCopyLoc = (from l in db.LocationContent
where l.IDcontent == query.IDcontent
select l.IDlocation).ToList();
foreach (var a in contCopyLoc)
{
var contLoc = db.LocationContent.Create();
contLoc.IDlocation = a;
contLoc.IDcontent = contCopy.IDcontent;
contLoc.TimeChanged = DateTime.Now;
db.LocationContent.Add(contLoc);
db.SaveChanges();
}
var contPage = db.ContentPage.Create();
contPage.IDcontent = contCopy.IDcontent;
contPage.IDuser = usernameCurrent.IDuser;
var pageSel = Request["PageDropDown"];
contPage.IDpage = Convert.ToInt32(pageSel);
db.ContentPage.Add(contPage);
db.SaveChanges();
}
if (Request["ContentTypeDropDown"].Any())
{
var contSel = Request["ContentTypeDropDown"];
query.IDcontentType = Convert.ToInt32(contSel);
}
/*if (Request["LocationEdit"].Any())// && queryLocation != null)
* {
* var locationSel = Request["LocationEdit"];
* queryLocation.IDlocation = Convert.ToInt32(locationSel);
* //db.Entry(queryLocation).State = EntityState.Modified;
* }*/
if (Request["LocationEdit"].Any())
{
var locationSel = Request["LocationEdit"];
var loc = Convert.ToInt32(locationSel);
var exists = from lc in db.LocationContent
where lc.IDlocation == loc &&
lc.IDcontent == IDcontent
select lc;
if (!exists.Any())
{
var location = db.LocationContent.Create();
location.IDlocation = Convert.ToInt32(locationSel);
location.IDcontent = IDcontent;
location.TimeChanged = DateTime.Now;
db.LocationContent.Add(location);
db.SaveChanges();
}
else
{
//return RedirectToAction("Edit", new { IDcontent = IDcontent });
return(Content("The selected location already contains this content.", "text/html"));
}
}
db.Entry(query).State = EntityState.Modified;
//db.Entry(queryPage).State = EntityState.Modified;
db.SaveChanges();
//return RedirectToAction("Edit", new { IDcontent = IDcontent, Username = username });
return(Content("Changes are successfully saved!", "text/html"));
}
}
return(View(model));
}
public async Task <ActionResult> Insert(string username, AddNewContentModel model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var user = db.User.FirstOrDefault(u => u.Username.Equals(username));
var currentUser = User.Identity.GetUserName();
var usernameCurrent = db.User.FirstOrDefault(u => u.Username.Equals(currentUser));
var newContent = db.Content.Create();
if (!Request["ContentTypeDropDown"].Any())
{
ModelState.AddModelError("", "Incorrect content.");
return(RedirectToAction("Insert", new { Username = username }));
}
var contSel = Request["ContentTypeDropDown"];
newContent.IDcontentType = Convert.ToInt32(contSel);
newContent.Text = model.Text;
newContent.IDauthor = user.IDuser;
newContent.IsCopied = false;
if (model.Title != null)
{
newContent.Title = model.Title;
}
else
{
newContent.Title = "(no title)";
}
newContent.IDeditor = user.IDuser;
newContent.TimeChanged = DateTime.Now;
db.Content.Add(newContent);
if (Request["LocationInsert"].Any())
{
var location = db.LocationContent.Create();
var locationSelect = Request["LocationInsert"];
location.IDlocation = Convert.ToInt32(locationSelect);
location.IDcontent = newContent.IDcontent;
location.TimeChanged = DateTime.Now;
db.LocationContent.Add(location);
db.SaveChanges();
}
db.SaveChanges();
if (Request["PageDropDown"].Any())
{
var contCopy = db.Content.Create();
contCopy.IDcontentType = newContent.IDcontentType;
contCopy.IDauthor = usernameCurrent.IDuser;
contCopy.Text = newContent.Text;
contCopy.Title = newContent.Title;
contCopy.IsCopied = true;
db.Content.Add(contCopy);
db.SaveChanges();
if (Request["LocationInsert"].Any())
{
var locCopy = db.LocationContent.Create();
var locationSelect = Request["LocationInsert"];
locCopy.IDlocation = Convert.ToInt32(locationSelect);
locCopy.IDcontent = contCopy.IDcontent;
locCopy.TimeChanged = DateTime.Now;
db.LocationContent.Add(locCopy);
db.SaveChanges();
}
var content = db.ContentPage.Create();
var pageSel = Request["PageDropDown"];
content.IDuser = user.IDuser;
content.IDpage = Convert.ToInt32(pageSel);
content.IDcontent = contCopy.IDcontent;
db.ContentPage.Add(content);
db.SaveChanges();
}
return(RedirectToAction("ViewContent", new { Username = username }));
}
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
/*if (ModelState.IsValid)
* {
* var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
* var result = await UserManager.CreateAsync(user, model.Password);
* if (result.Succeeded)
* {
* await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
*
* // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
* // Send an email with this link
* // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
* // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
* // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
*
* return RedirectToAction("Index", "Home");
* }
* AddErrors(result);
* }*/
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var newUser = db.User.Create();
bool userExists = db.User.Any(user => user.Username == model.Username);
newUser.Username = model.Username;
newUser.Password = model.Password;
newUser.Email = model.Email;
newUser.FirstName = model.FirstName;
newUser.LastName = model.LastName;
if (Request["CityDropDownList"].Any())
{
var citySel = Request["CityDropDownList"];
newUser.IDcityFrom = Convert.ToInt32(citySel);
}
if (!userExists)
{
db.User.Add(newUser);
db.SaveChanges();
var userGroup = db.BelongsToGroup.Create();
userGroup.IDgroup = 1;
userGroup.IDuser = newUser.IDuser;
userGroup.TimeChanged = DateTime.Now;
db.BelongsToGroup.Add(userGroup);
db.SaveChanges();
FormsAuthentication.SetAuthCookie(model.Username, false);
var FormsAuthCookie = Response.Cookies[FormsAuthentication.FormsCookieName];
var ExistingTicket = FormsAuthentication.Decrypt(FormsAuthCookie.Value).Name;
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "The user with this username already exists, please choose another username!");
model.Username = "";
return(View(model));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> EditPage(int IDpage, string username, EditPageModel model)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var selPage = db.Page.FirstOrDefault(u => u.IDpage.Equals(IDpage));
if (ModelState.IsValid)
{
var user = db.User.FirstOrDefault(u => u.Username.Equals(username));
selPage.name = model.PageTitle;
if (model.PageTitle == null)
{
return(Content("Page title cannot be empty!", "text/html"));
}
if (Request["PrivacyDropDown"].Any())
{
var privSel = Request["PrivacyDropDown"];
var privacy = Convert.ToInt32(privSel);
selPage.IDprivacy = privacy;
}
selPage.IDeditor = user.IDuser;
selPage.TimeChanged = DateTime.Now;
if (model.Tag != null)
{
var tagModel = model.Tag.ToLower();
var existsInPage = from p in db.PageTag
join t in db.Tag on p.IDtag equals t.ID
where t.name == tagModel
select t;
var existsTag = from t in db.Tag
where t.name == tagModel
select t;
if (!existsTag.Any())
{
var newTag = db.Tag.Create();
newTag.name = tagModel;
db.Tag.Add(newTag);
db.SaveChanges();
}
if (!existsInPage.Any())
{
var newPageTag = db.PageTag.Create();
newPageTag.IDtag = existsTag.First().ID;
newPageTag.IDpage = IDpage;
db.PageTag.Add(newPageTag);
db.SaveChanges();
}
}
if (model.Contributor != null)
{
var userExists = from u in db.User
where u.Username == model.Contributor
select u;
if (!userExists.Any())
{
//return RedirectToAction("Edit", new { IDpage = IDpage, Username = username });
return(Content("User does not exist, please try again!", "text/html"));
}
var exists = from t in db.Contributor
join u in db.User on t.IDuser equals u.IDuser
where u.Username == model.Contributor &&
t.IDpage == IDpage
select t;
if (!exists.Any())
{
var contribUser = db.User.FirstOrDefault(u => u.Username.Equals(model.Contributor));
var newContributor = db.Contributor.Create();
newContributor.IDpage = IDpage;
newContributor.IDuser = contribUser.IDuser;
newContributor.IsAuthor = false;
db.Contributor.Add(newContributor);
db.SaveChanges();
}
}
db.Entry(selPage).State = EntityState.Modified;
db.SaveChanges();
//return RedirectToAction("Edit", new { IDpage = IDpage, Username = username });
return(Content("Changes were successfully saved!", "text/html"));
}
}
return(Content("Edit failed, please try again!", "text/html"));
//return RedirectToAction("Edit", new { IDpage = IDpage, Username = username });
}
