public bool DeleteList(int List)
{
try
{
//items, users and then list
OneListEntitiesCore db = new OneListEntitiesCore();
//1.- first delete items.
IEnumerable <ListItem> lItems = db.ListItems.Where(li => li.ListID == List).Select(p => p);
db.ListItems.RemoveRange(lItems);
//2.- remove users
IEnumerable <ListUser> lUsers = db.ListUsers.Where(lu => lu.ListID == List).Select(p => p);
db.ListUsers.RemoveRange(lUsers);
//3.- finally Remove list
List L = db.Lists.Where(l => l.ListID == List).Select(p => p).First();
db.Lists.Remove(L);
db.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
return(true);
}
/* *******************************************************
* AddUserToGroup
* Parameter: string userID
********************************************************/
public void AddUserToGroup(SubscriberGroupVM subGroup, out string errMsg)
{
// TO DO: server side validation & client side validation
var now = DateTime.UtcNow;
OneListEntitiesCore db = new OneListEntitiesCore();
SuscriberGroup sGroup = db.SuscriberGroups.Where(a => a.SuscriberGroupID == subGroup.SubscriberGroupID).FirstOrDefault();
SuscriberGroupUser newGroupUser = new SuscriberGroupUser();
newGroupUser.UserID = subGroup.UserID;
newGroupUser.SuscriberGroupID = subGroup.SubscriberGroupID;
newGroupUser.UserTypeID = DEFAULT_USER_TYPE;
newGroupUser.ListUserStatus = DEFAULT_STATUS;
newGroupUser.SuscriptionDate = now.ToShortDateString();
newGroupUser.SuscriberGroup = sGroup; //Add subscriberGroup property !important
var query = db.SuscriberGroupUsers.Add(newGroupUser);
SuscriberGroupUser existingUser = db.SuscriberGroupUsers
.Where(a =>
a.SuscriberGroupID == subGroup.SubscriberGroupID &&
a.UserID == subGroup.UserID
).FirstOrDefault();
// Check if the user currently exist in the table
if (existingUser == null)
{
db.SaveChanges();
errMsg = "User Added.";
}
else
{
errMsg = "User Already Exist.";
}
}
public void DeleteItem(int itemId, out string errMsg)
{
OneListEntitiesCore db = new OneListEntitiesCore();
Item itemToBeDeleted = db.Items.Where(a => a.ItemID == itemId).FirstOrDefault();
var itemWithList = db.ListItems
.Where(l => l.ItemID == itemId)
.FirstOrDefault();
if (itemWithList != null)
{
errMsg = "Item used in list, cannot be deleted";
}
else
{
if (itemToBeDeleted != null)
{
db.Items.Remove(itemToBeDeleted);
db.SaveChanges();
errMsg = "Item Deleted";
}
else
{
errMsg = "Item could not be deleted.";
}
}
}
public void CreateItem(ItemVM item)
{
//if (String.IsNullOrEmpty(item.ItemName))
//{
// errMsg = "name field empty";
//}else
//{
OneListEntitiesCore db = new OneListEntitiesCore();
Item itemAdded = new Item();
itemAdded.UserID = item.UserID;
itemAdded.ItemName = item.ItemName;
itemAdded.ItemDescription = item.ItemDescription;
itemAdded.ItemCategory = (int)item.ItemCategory;
//if (itemAdded.ItemCategory == 0)
//{
// errMsg = "Items must belong to a category";
//}
//else {
db.Items.Add(itemAdded);
db.SaveChanges();
//errMsg = "Item successfully added";
//}
//}
}
public IEnumerable <ListViewVM> GetLists(string UserID)
{
OneListEntitiesCore db = new OneListEntitiesCore();
IEnumerable <List> lists = db.Lists.Where(l => l.CreatorID == UserID && l.ListStatusID == PROCESS).Select(list => list);
IEnumerable <ListViewVM> ListReturn;
var r = new List <ListViewVM>();
foreach (List single in lists)
{
ListViewVM oneList = new ListViewVM();
oneList.CreatorID = UserID;
oneList.ListStatusID = single.ListStatusID;
oneList.ListTypeID = single.ListTypeID;
oneList.ListID = single.ListID;
oneList.CreationDate = single.CreationDate.ToShortDateString();
oneList.ListName = single.ListName;
oneList.SuscriberGroup = from groups in db.SuscriberGroups
join ListUser l in db.ListUsers
on groups.SuscriberGroupID equals l.SuscriberGroupID
join List li in db.Lists
on l.ListID equals li.ListID
where li.CreatorID == UserID
where li.ListID == oneList.ListID
select groups;
oneList.ListType = db.ListTypes.Where(lt => lt.ListTypeID == single.ListTypeID).Select(p => p).FirstOrDefault().TypeName;
r.Add(oneList);
}
ListReturn = (IEnumerable <ListViewVM>)r;
return(ListReturn);
}
public IEnumerable <ListViewVM> GetSuscribedLists(string UserID)
{
IEnumerable <ListViewVM> ListReturn;
try
{
OneListEntitiesCore db = new OneListEntitiesCore();
IEnumerable <List> lists = from list in db.Lists
join ListUser luser in db.ListUsers
on list.ListID equals luser.ListID
join SuscriberGroupUser sg in db.SuscriberGroupUsers
on luser.SuscriberGroupID equals sg.SuscriberGroupID
where sg.UserID == UserID && sg.UserTypeID != 1
select list;
IEnumerable <SuscriberGroupUser> user = from list in db.Lists
join ListUser luser in db.ListUsers
on list.ListID equals luser.ListID
join SuscriberGroupUser sg in db.SuscriberGroupUsers
on luser.SuscriberGroupID equals sg.SuscriberGroupID
where sg.UserID == UserID && sg.UserTypeID != 1
select sg;
SuscriberGroupUser userFinal = user.First();
var r = new List <ListViewVM>();
foreach (List single in lists)
{
ListViewVM oneList = new ListViewVM();
oneList.CreatorID = UserID;
oneList.ListStatusID = single.ListStatusID;
oneList.ListTypeID = single.ListTypeID;
oneList.ListID = single.ListID;
oneList.CreationDate = single.CreationDate.ToShortDateString();
oneList.ListName = single.ListName;
oneList.SuscriberGroup = from groups in db.SuscriberGroups
join ListUser l in db.ListUsers
on groups.SuscriberGroupID equals l.SuscriberGroupID
join List li in db.Lists
on l.ListID equals li.ListID
where li.CreatorID == UserID
where li.ListID == oneList.ListID
select groups;
UserType currentUser = db.UserTypes.Where(ut => ut.UserTypeID == userFinal.UserTypeID).Select(o => o).FirstOrDefault();
oneList.suscriberRole = currentUser.UserTypeName;
oneList.UserType = user.First().UserTypeID;
oneList.ListType = db.ListTypes.Where(lt => lt.ListTypeID == single.ListTypeID).Select(p => p).FirstOrDefault().TypeName;
r.Add(oneList);
}
ListReturn = (IEnumerable <ListViewVM>)r;
}
catch
{
ListReturn = null;
}
return(ListReturn);
}
public ListVM CreateList(string UserID)
{
OneListEntitiesCore db = new OneListEntitiesCore();
ListVM cleanList = new ListVM();
cleanList.ListType = db.ListTypes.Select(s => s);
cleanList.ItemCategory = db.ItemCategories.Where(cat => cat.UserID == UserID).Select(s => s);
cleanList.SuscriberGroup = db.SuscriberGroups.Where(group => group.UserID == UserID).Select(s => s);
return(cleanList);
}
public void CreateItemCategory(ItemCategoryVM itemCategory, string userID)
{
ItemCategory c = new ItemCategory();
c.ItemCategoryName = itemCategory.ItemCategoryName;
c.ItemCategoryID = 0;
c.UserID = userID;
OneListEntitiesCore Core = new OneListEntitiesCore();
Core.ItemCategories.Add(c);
Core.SaveChanges();
}
public bool CreateList(ListVM list)
{
try
{
OneListEntitiesCore db = new OneListEntitiesCore();
//first, create List
List newList = new List();
newList.CreationDate = list.CreationDate;
newList.CreatorID = list.CreatorID;
newList.ListName = list.ListName;
newList.ListTypeID = list.ListTypeID;
newList.ListStatusID = 1;
List createdList = db.Lists.Add(newList);
//then create list items and users
db.SaveChanges();
//list users
string[] groups = list.SuscribergroupID.Split(',');
foreach (string group in groups)
{
ListUser Luser = new ListUser();
Luser.ListID = createdList.ListID;
Luser.SuscriberGroupID = int.Parse(group);
Luser.SuscriptionDate = list.CreationDate.ToShortDateString();
ListUser createdLuser = db.ListUsers.Add(Luser);
db.SaveChanges();
}
//listitems
IEnumerable <Item> selectedItems = db.Items
.Where(a => a.ItemCategory == list.ItemCategoryID && a.UserID == list.CreatorID)
.Select(s => s);
foreach (Item sel in selectedItems)
{
ListItem lItem = new ListItem();
lItem.ItemID = sel.ItemID;
lItem.ListID = createdList.ListID;
lItem.ListItemSolved = false;
lItem.ListItemSolvingDate = DateTime.Today;
db.ListItems.Add(lItem);
}
db.SaveChanges();
return(true);
}
catch (Exception ex) {
return(false);
}
}
public bool UpdateItem(ItemVM item)
{
OneListEntitiesCore db = new OneListEntitiesCore();
Item itemUpdated = db.Items.Where(a => a.ItemID == item.ItemID).FirstOrDefault();
itemUpdated.ItemName = item.ItemName;
itemUpdated.ItemDescription = item.ItemDescription;
itemUpdated.ItemCategory = item.ItemCategory;
db.SaveChanges();
return(true);
}
/* *******************************************************
* Get all subscriber Group
* Return: void
********************************************************/
public IEnumerable <SubscriberGroupVM> GetSubscriberGroups(string publisherID)
{
OneListEntitiesCore db = new OneListEntitiesCore();
IEnumerable <SubscriberGroupVM> subscriberGroups = db.SuscriberGroups
.Where(a => a.UserID == publisherID)
.Select(s => new SubscriberGroupVM()
{
SubscriberGroupID = s.SuscriberGroupID,
SubscriberGroupName = s.SuscriberGroupName
});
return(subscriberGroups);
}
public IEnumerable <ItemCategoryVM> GetItemCategories(string userID)
{
OneListEntitiesCore db = new OneListEntitiesCore();
IEnumerable <ItemCategoryVM> itemList = db.ItemCategories
.Where(a => a.UserID == userID)
.Select(p => new ItemCategoryVM()
{
ItemCategoryID = p.ItemCategoryID,
ItemCategoryName = p.ItemCategoryName
});
return(itemList);
}
/* *******************************************************
* GetAllUsers
* Return: IEnumerable<SelectListItem>
********************************************************/
public IEnumerable <SelectListItem> GetAllUsers()
{
OneListEntitiesCore db = new OneListEntitiesCore();
var categories = db.Users
.Select(x =>
new SelectListItem
{
Value = x.UserID.ToString(),
Text = x.Email
});
return(new SelectList(categories, "Value", "Text"));
}
public IEnumerable <SelectListItem> GetCategories(string userId)
{
OneListEntitiesCore db = new OneListEntitiesCore();
var categories = db.ItemCategories
.Where(a => a.UserID == userId)
.Select(x => new SelectListItem
{
Value = x.ItemCategoryID.ToString(),
Text = x.ItemCategoryName
});
return(categories);
}
public bool UpdateItemCategory(ItemCategoryVM itemCategory)
{
OneListEntitiesCore db = new OneListEntitiesCore();
ItemCategory itemCategoryUpdated = db.ItemCategories
.Where(a =>
a.ItemCategoryID == itemCategory.ItemCategoryID
)
.FirstOrDefault();
itemCategoryUpdated.ItemCategoryName = itemCategory.ItemCategoryName;
db.SaveChanges();
return(true);
}
/* *******************************************************
* GetGroupDetails
* Parameter: int GroupID
* return: SubscriberGroupVM
********************************************************/
public SubscriberGroupVM GetGroupDetails(int id)
{
OneListEntitiesCore db = new OneListEntitiesCore();
SuscriberGroup groupToBeUpdated = db.SuscriberGroups
.Where(a =>
a.SuscriberGroupID == id
).FirstOrDefault();
SubscriberGroupVM sg = new SubscriberGroupVM();
sg.SubscriberGroupID = groupToBeUpdated.SuscriberGroupID;
sg.SubscriberGroupName = groupToBeUpdated.SuscriberGroupName;
sg.UserList = GetAllUsers();
sg.allSubscribedUsers = GetAllSubscribedUsers(id);
return(sg);
}
public bool deleteItemList(int itemID, int listID)
{
try
{
OneListEntitiesCore db = new OneListEntitiesCore();
ListItem l = db.ListItems.Where(p => p.ItemID == itemID && p.ListID == listID).Select(r => r).First();
db.ListItems.Remove(l);
db.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
/* *******************************************************
* GetSubscriberGroupUsers
* Return: IEnumerable<SubscriberGroupUserVM>
********************************************************/
public IEnumerable <SubscriberGroupUserVM> GetSubscriberGroupUsers(int id)
{
OneListEntitiesCore db = new OneListEntitiesCore();
IEnumerable <SubscriberGroupUserVM> subscriberGroupUsers = db.SuscriberGroupUsers.Select(a =>
new SubscriberGroupUserVM()
{
SubscriberGroupID = id,
UserID = a.UserID,
ListUserStatus = a.ListUserStatus,
UserTypeID = a.UserTypeID,
SubscriptionDate = a.SuscriptionDate
});
return(subscriberGroupUsers);
}
public IEnumerable <ItemVM> GetAll(string userId)
{
OneListEntitiesCore db = new OneListEntitiesCore();
IEnumerable <ItemVM> itemList = db.ItemCategories
.SelectMany(a => a.Items.Where(b => b.UserID == userId)
.Select(it => new ItemVM()
{
ItemID = it.ItemID,
ItemName = it.ItemName,
ItemDescription = it.ItemDescription,
ItemCategory = (int)it.ItemCategory,
ItemCategoryName = a.ItemCategoryName
}));
return(itemList);
}
public ItemVM GetDetails(int itemId)
{
OneListEntitiesCore db = new OneListEntitiesCore();
Item itemToBeUpdated = db.Items.Where(a => a.ItemID == itemId).FirstOrDefault();
ItemVM iv = new ItemVM();
iv.ItemID = itemToBeUpdated.ItemID;
iv.UserID = itemToBeUpdated.UserID;
iv.ItemName = itemToBeUpdated.ItemName;
iv.ItemDescription = itemToBeUpdated.ItemDescription;
iv.ItemCategory = (int)itemToBeUpdated.ItemCategory;
ItemCategory categoryDb = db.ItemCategories.Where(a => a.ItemCategoryID == iv.ItemCategory).FirstOrDefault();
iv.ItemCategoryName = categoryDb.ItemCategoryName;
return(iv);
}
public ActionResult Edit(UserVM userInput)
{
if (userInput.FirstName != null && userInput.LastName != null)
{
OneListEntitiesCore db = new OneListEntitiesCore();
User user = db.Users.Where(a => a.UserName == User.Identity.Name).FirstOrDefault();
user.FirstName = userInput.FirstName;
user.LastName = userInput.LastName;
db.SaveChanges();
TempData["Success"] = "Updated successfully!";
}
else
{
TempData["Fail"] = "Failed to update!";
}
return(RedirectToAction("Index", "Profile"));
}
public bool CompleteList(int id, string userID)
{
try
{
//items, users and then list
OneListEntitiesCore db = new OneListEntitiesCore();
//1.- complete list.
List l = db.Lists.Where(p => p.ListID == id).Select(r => r).First();
//change status to complete
l.ListStatusID = COMPLETED;//completed
db.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public ActionResult AddSubscriberGroup(SubscriberGroupVM subscriberGroup)
{
subscriberGroup.UserID = FindUserID();
if (ModelState.IsValid)
{
SuscriberGroup sg = new SuscriberGroup();
sg.SuscriberGroupName = subscriberGroup.SubscriberGroupName;
sg.UserID = subscriberGroup.UserID;
OneListEntitiesCore Core = new OneListEntitiesCore();
Core.SuscriberGroups.Add(sg);
Core.SaveChanges();
}
else
{
ViewBag.ErrorMsg = "Cannot add Subscriber Group.";
}
return(View());
}
public bool UpdateListData(int id, string name, int listType, int[] groups)
{
//update lists
try
{
OneListEntitiesCore db = new OneListEntitiesCore();
//first, select List
List newList = db.Lists.Where(p => p.ListID == id).Select(r => r).FirstOrDefault();
//change name
newList.ListName = name;
//change type
newList.ListTypeID = listType;
//last part,delete groups first, add them again
IEnumerable <ListUser> currentGroups = db.ListUsers.Where(p => p.ListID == id).Select(r => r);
db.ListUsers.RemoveRange(currentGroups);
db.SaveChanges();
foreach (int group in groups)
{
ListUser Luser = new ListUser();
Luser.ListID = id;
Luser.SuscriberGroupID = group;
Luser.SuscriptionDate = DateTime.Today.ToShortDateString();
db.ListUsers.Add(Luser);
db.SaveChanges();
}
db.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
return(true);
}
/* *******************************************************
* UpdateGroup
* Return: bool
********************************************************/
public bool UpdateGroup(SubscriberGroupVM subscriberGroup)
{
try {
OneListEntitiesCore db = new OneListEntitiesCore();
SuscriberGroup groupUpdated = db.SuscriberGroups
.Where(a =>
a.SuscriberGroupID == subscriberGroup.SubscriberGroupID
).FirstOrDefault();
groupUpdated.SuscriberGroupName = subscriberGroup.SubscriberGroupName;
db.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
// GET: Profile
public ActionResult Index()
{
if (Request.IsAuthenticated)
{
var username = User.Identity.Name;
OneListEntitiesCore db = new OneListEntitiesCore();
User user = db.Users.Where(a => a.UserName == username).FirstOrDefault();
UserVM userForView = new UserVM();
userForView.FirstName = user.FirstName;
userForView.LastName = user.LastName;
userForView.UserName = user.UserName;
userForView.Email = user.Email;
return(View(userForView));
}
else
{
return(RedirectToAction("Login", "Home"));
}
}
public ItemCategoryVM GetCategoryDetails(int itemCategoryID)
{
OneListEntitiesCore db = new OneListEntitiesCore();
ItemCategory category = db.ItemCategories
.Where(ic => ic.ItemCategoryID == itemCategoryID)
.FirstOrDefault();
IEnumerable <ItemVM> allItems = db.Items
.Where(i => i.ItemCategory == itemCategoryID)
.Select(item => new ItemVM
{
ItemName = item.ItemName,
ItemDescription = item.ItemDescription
});
ItemCategoryVM categoryVM = new ItemCategoryVM();
categoryVM.ItemCategoryName = category.ItemCategoryName;
categoryVM.UserID = category.UserID;
categoryVM.ItemCategoryID = itemCategoryID;
categoryVM.allItemsInCategory = allItems;
return(categoryVM);
}
/* *******************************************************
* GetAllSubscribedUsers
* Return: IEnumerable<SelectListItem>
********************************************************/
public IEnumerable <SubscriberGroupUserVM> GetAllSubscribedUsers(int id)
{
// IEnumerable<SubscriberGroupUserVM> groupUserList;
OneListEntitiesCore db = new OneListEntitiesCore();
var groupUserList = db.SuscriberGroups
.Where(a => a.SuscriberGroupID == id)
.SelectMany(groups =>
groups.SuscriberGroupUsers.Select(
x =>
new SubscriberGroupUserVM
{
UserID = x.UserID,
ListUserStatus = x.ListUserStatus,
UserTypeID = x.UserTypeID,
Email = x.User.Email,
FullName = x.User.FirstName + " " + x.User.LastName
}));
return(groupUserList);
}
/* *******************************************************
* DeleteSubscriber
* Void
********************************************************/
public void DeleteSubscriber(string userId, int id, out string errMsg)
{
OneListEntitiesCore db = new OneListEntitiesCore();
SuscriberGroupUser subscriberToBeDeleted = db.SuscriberGroupUsers
.Where(s =>
s.UserID == userId &&
s.SuscriberGroupID == id
)
.FirstOrDefault();
if (subscriberToBeDeleted != null)
{
db.SuscriberGroupUsers.Remove(subscriberToBeDeleted);
db.SaveChanges();
errMsg = "Subscriber Deleted";
}
else
{
errMsg = "Subscriber could not be deleted.";
}
}
/* *******************************************************
* Change Subscriber Status
* Void
********************************************************/
public void ChangeSubscriberStatus(string userId, int id, out string errMsg)
{
OneListEntitiesCore db = new OneListEntitiesCore();
SuscriberGroupUser subscriberStatusToBeChanged = db.SuscriberGroupUsers
.Where(s =>
s.UserID == userId &&
s.SuscriberGroupID == id
)
.FirstOrDefault();
if (subscriberStatusToBeChanged != null)
{
subscriberStatusToBeChanged.ListUserStatus = GetStatusToBeChanged(subscriberStatusToBeChanged.ListUserStatus);
db.SaveChanges();
errMsg = "Subscriber Type Changed";
}
else
{
errMsg = "Subscriber type could not be changed.";
}
}
