public static bool Add(UsersToEvent usersToEvent)
{
bool successful = false;
if (usersToEvent == null)
{
return(successful);
}
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UsersToEvent> repository = new Repository <UsersToEvent>(unitOfWork);
if (!repository.Get(ute => ute.UserID == usersToEvent.UserID && ute.EventID == usersToEvent.EventID).Any())
{
usersToEvent.UnitState = UnitState.Added;
usersToEvent = repository.Create(usersToEvent);
unitOfWork.Commit();
successful = true;
}
else
{
successful = false;
}
}
return(successful);
}
public static bool Remove(UsersToEvent usersToEvent)
{
bool successful = false;
if (usersToEvent == null)
{
return(successful);
}
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UsersToEvent> repository = new Repository <UsersToEvent>(unitOfWork);
usersToEvent = GetEventID(usersToEvent.UserID, usersToEvent.EventID);
if (usersToEvent != null)
{
usersToEvent.UnitState = UnitState.Deleted;
repository.Delete(usersToEvent);
unitOfWork.Commit();
successful = true;
}
}
return(successful);
}
public static bool IsModerator(int userID, int groupID)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UsersToGroup> repository = new Repository <UsersToGroup>(unitOfWork);
return(repository.Contains(ut2g => ut2g.User.ID == userID && ut2g.GroupID == groupID && ut2g.GroupRoleID == (int)DML.Enums.GroupRoles.Moderator));
}
}
public static bool HasPermission(int id, DML.Enums.PermissionsItem permissionsItem)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UserTypesToPermission> repository = new Repository <UserTypesToPermission>(unitOfWork);
return(repository.Contains(ut2p => ut2p.PermissionID == (int)permissionsItem && ut2p.UserType.Users.Any(u => u.ID == id)));
}
}
public static bool IsOwner(int ownerID, int groupID)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Group> repository = new Repository <Group>(unitOfWork);
return(repository.Contains(g => g.ID == groupID && g.OwnerID == ownerID));
}
}
public static User GetById(int id, UserRelatedData relatedData = UserRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <User> repository = new Repository <User>(unitOfWork);
return(repository.Get(u => u.ID == id, null, GetIncludeProperties(relatedData)).SingleOrDefault()); // && u.IsApproved
}
}
public static bool IsMember(int userID, int groupID)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UsersToGroup> repository = new Repository <UsersToGroup>(unitOfWork);
return(repository.Contains(ut2g => ut2g.User.ID == userID && ut2g.GroupID == groupID));
}
}
public static UsersToGroup GetByUserIDGroupID(int userID, int groupID, UsersToGroupRelatedData relatedData = UsersToGroupRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UsersToGroup> repository = new Repository <UsersToGroup>(unitOfWork);
UsersToGroup userToGroup = repository.Get(x => x.GroupID == groupID && x.UserID == userID, GetIncludeProperties(relatedData)).SingleOrDefault();
return(userToGroup);
}
}
public static List <UsersToEvent> GetPagedUsersToEventsByUserID(int userID, int pageNumber, int pageSize = int.MaxValue, UsersToEventRelatedData relatedData = UsersToEventRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UsersToEvent> repository = new Repository <UsersToEvent>(unitOfWork);
List <UsersToEvent> events = repository.Get(e => e.UserID == userID && e.Event.StartTime > DateTime.Today, GetIncludeProperties(relatedData)).OrderBy(e => e.Event.StartTime).ToPagedList(pageNumber, pageSize).ToList();
return(events);
}
}
public static UsersToEvent GetEventID(int UserID, int EventID)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UsersToEvent> repository = new Repository <UsersToEvent>(unitOfWork);
UsersToEvent userToEvent = repository.Get(x => x.EventID == EventID && x.UserID == UserID).SingleOrDefault();
return(userToEvent);
}
}
public static DML.Event GetEventByID(int id, EventRelatedData relatedData = EventRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Event> repository = new Repository <Event>(unitOfWork);
Event singleEvent = repository.Get(e => e.ID == id, GetIncludeProperties(relatedData)).SingleOrDefault(); //"UsersToEvents.User"
return(singleEvent);
}
}
//public static IPagedList<DML.Event> PreparePagedEvents(int pageNumber, IUnitOfWork unitOfWork, int pageSize = int.MaxValue, EventRelatedData relatedData = EventRelatedData.None)
//{
// Repository<Event> repository = new Repository<Event>(unitOfWork);
// IPagedList<Event> events = repository.Get(e => e.IsPublic == true, GetIncludeProperties(relatedData)).OrderBy(e => e.StartTime).ToPagedList(pageNumber, pageSize);
// return events;
//}
public static IPagedList <DML.Event> GetPagedEventsByUserID(int userID, int pageNumber, int pageSize = int.MaxValue, EventRelatedData relatedData = EventRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Event> repository = new Repository <Event>(unitOfWork);
IPagedList <Event> events = repository.Get(e => e.IsPublic == true || e.Group.UsersToGroups.Any(ut2g => ut2g.UserID == userID), GetIncludeProperties(relatedData)).OrderBy(e => e.StartTime).ToPagedList(pageNumber, pageSize);
return(events);
}
}
public static Group GetGroupByID(int id, GroupRelatedData relatedData = GroupRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Group> repository = new Repository <Group>(unitOfWork);
Group singleGroup = repository.Get(g => g.ID == id, GetIncludeProperties(relatedData)).SingleOrDefault();
return(singleGroup);
}
}
public static IPagedList <DML.Event> GetPagedEvents(int pageNumber, int pageSize = int.MaxValue, EventRelatedData relatedData = EventRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Event> repository = new Repository <Event>(unitOfWork);
IPagedList <Event> events = repository.Get(null, GetIncludeProperties(relatedData)).OrderBy(e => e.StartTime).ToPagedList(pageNumber, pageSize);
return(events);
}
}
public static List <GroupInvite> GetGroupInviteByUserName(string userName, GroupInviteRelatedData relatedData = GroupInviteRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <GroupInvite> repository = new Repository <GroupInvite>(unitOfWork);
List <GroupInvite> singleGroupInvite = repository.Get(gi => gi.UserMail == userName, GetIncludeProperties(relatedData)).ToList();
return(singleGroupInvite);
}
}
public static Event Add(DML.Event eventAdd)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Event> repository = new Repository <Event>(unitOfWork);
eventAdd.UnitState = UnitState.Added;
Event returnEvent = repository.Create(eventAdd);
unitOfWork.Commit();
return(returnEvent);
}
}
public static bool Add(UsersToGroup usersToGroup)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <UsersToGroup> repository = new Repository <UsersToGroup>(unitOfWork);
usersToGroup.UnitState = UnitState.Added;
usersToGroup = repository.Create(usersToGroup);
unitOfWork.Commit();
return(true);
}
}
public static string GetPermissionForUser(string username)
{
using (IUnitOfWork unitofWork = new cmiUnitOfWork())
{
User user = UserManager.GetByUsername(username, UserManager.UserRelatedData.Type);
if (user != null)
{
return(user.UserType.Name);
}
return(DML.Enums.UserType.Unknow.ToString());
}
}
public static bool Remove(int id)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <GroupInvite> repository = new Repository <GroupInvite>(unitOfWork);
//usersToGroup.UnitState = UnitState.Deleted;
//repository.Delete(GetGroupID(usersToGroup.UserID, usersToGroup.GroupID));
repository.Delete(id);
unitOfWork.Commit();
return(true);
}
}
public static GroupEventItems GetGroupEventItemsByID(int id, int pageNumber, int pageSize = int.MaxValue, GroupRelatedData relatedData = GroupRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
GroupEventItems groupEvents = new GroupEventItems();
Repository <Group> repositoryGroup = new Repository <Group>(unitOfWork);
groupEvents.Group = repositoryGroup.Get(g => g.ID == id, GetIncludeProperties(relatedData)).SingleOrDefault();
Repository <Event> repositoryEvent = new Repository <Event>(unitOfWork);
groupEvents.Events = repositoryEvent.Get(e => e.GroupID == id, "UsersToEvents").OrderBy(e => e.StartTime).ToPagedList(pageNumber, pageSize);
return(groupEvents);
}
}
public static bool Delete(int id)
{
bool successful = false;
User user = GetById(id, UserRelatedData.All);
if (user == null)
{
return(successful);
}
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <User> repository = new Repository <User>(unitOfWork);
user.UnitState = UnitState.Deleted;
foreach (Group item in user.Groups)
{
DAL.DalHelper <GroupInvite> .RemoveCollection(item.GroupInvites);
foreach (var eventItem in item.Events)
{
DAL.DalHelper <UsersToEvent> .RemoveCollection(eventItem.UsersToEvents);
eventItem.UnitState = UnitState.Deleted;
}
DAL.DalHelper <UsersToGroup> .RemoveCollection(item.UsersToGroups);
}
foreach (Event item in user.Events)
{
DAL.DalHelper <UsersToEvent> .RemoveCollection(item.UsersToEvents);
item.UnitState = UnitState.Deleted;
}
DAL.DalHelper <UsersToGroup> .RemoveCollection(user.UsersToGroups);
DAL.DalHelper <UsersToEvent> .RemoveCollection(user.UsersToEvents);
user.UnitState = UnitState.Deleted;
repository.Attach(user);
unitOfWork.Commit();
successful = true;
}
return(successful);
}
public static LoginState Validate(string username, string password, out User user)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
//string passwordHash = Utils.
Repository <User> repository = new Repository <User>(unitOfWork);
user = repository.Get(u => u.UserName == username && u.Password == password).SingleOrDefault(); // && u.IsApproved
if (user != null)
{
return(LoginState.Success); //user.IsApproved ? LoginState.Success : LoginState.NotApproved;
}
}
return(LoginState.Error);
}
public static bool Create(User user)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <User> repository = new Repository <User>(unitOfWork);
if (!repository.Get(u => u.UserName == user.UserName).Any())
{
user.UnitState = UnitState.Added;
user = repository.Create(user);
unitOfWork.Commit();
return(true);
}
else
{
return(false);
}
}
}
public static ProfileItem GetProfileByUserId(int id, int eventNumber, UserRelatedData relatedData = UserRelatedData.None)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <User> repositoryUser = new Repository <User>(unitOfWork);
User outUser = repositoryUser.Get(u => u.ID == id, null, GetIncludeProperties(relatedData)).SingleOrDefault();
Repository <GroupInvite> repositoryGroupInvite = new Repository <GroupInvite>(unitOfWork);
List <GroupInvite> outGroupInvite = repositoryGroupInvite.Get(gi => gi.UserMail == outUser.UserName, "Group").ToList();
Repository <UsersToEvent> repositoryUsersToEvent = new Repository <UsersToEvent>(unitOfWork);
List <UsersToEvent> outUsersToEvent = repositoryUsersToEvent.Get(ue => ue.UserID == id && ue.Event.StartTime >= DateTime.Today, "Event").Take(eventNumber).ToList();
return(new ProfileItem {
user = outUser, groupInvite = outGroupInvite, usersToEvent = outUsersToEvent
});
}
}
public static Group Create(DML.Group groupAdd)
{
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Group> repository = new Repository <Group>(unitOfWork);
if (!repository.Get(g => g.Name == groupAdd.Name).Any())
{
groupAdd.UnitState = UnitState.Added;
Group returnGroup = repository.Create(groupAdd);
unitOfWork.Commit();
return(returnGroup);
}
else
{
return(null);
}
}
}
public static bool Update(User user)
{
bool successful = false;
if (user == null)
{
return(successful);
}
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <User> repository = new Repository <User>(unitOfWork);
user.UnitState = UnitState.Modified;
repository.Update(user);
unitOfWork.Commit();
successful = true;
}
return(successful);
}
public static bool Remove(Event eventItem)
{
bool successful = false;
if (eventItem == null)
{
return(successful);
}
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Event> repository = new Repository <Event>(unitOfWork);
eventItem.UnitState = UnitState.Deleted;
repository.Delete(eventItem.ID);
unitOfWork.Commit();
successful = true;
}
return(successful);
}
public static bool Remove(GroupInvite groupInvite)
{
bool successful = false;
if (groupInvite == null)
{
return(successful);
}
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <GroupInvite> repository = new Repository <GroupInvite>(unitOfWork);
groupInvite.UnitState = UnitState.Deleted;
repository.Delete(groupInvite.ID);
unitOfWork.Commit();
successful = true;
}
return(successful);
}
public static bool Remove(int id)
{
bool successful = false;
Group group = GetGroupByID(id, GroupRelatedData.ALL);
if (group == null)
{
return(successful);
}
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
PrepareRemoveGroup(unitOfWork, group);
successful = true;
}
return(successful);
}
public static bool Update(DML.Event eventUpdate)
{
bool successful = false;
if (eventUpdate == null)
{
return(successful);
}
using (IUnitOfWork unitOfWork = new cmiUnitOfWork())
{
Repository <Event> repository = new Repository <Event>(unitOfWork);
eventUpdate.UnitState = UnitState.Modified;
repository.Update(eventUpdate);
unitOfWork.Commit();
successful = true;
}
return(successful);
}
