/// <summary>
        /// Add or update new user group.
        /// </summary>
		public GXUserGroupUpdateResponse Put(GXUserGroupUpdateRequest request)
		{
            IAuthSession s = this.GetSession(false);
            //Normal user can't change user group name or add new one.
            if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
            {
                throw new ArgumentException("Access denied.");
            }
            long adderId = Convert.ToInt64(s.Id);
            List<GXEventsItem> events = new List<GXEventsItem>();
            lock (Db)
            {
                using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
                {
                    bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
                    //Add new user groups           
                    foreach (GXAmiUserGroup it in request.UserGroups)
                    {
                        if (string.IsNullOrEmpty(it.Name))
                        {
                            throw new ArgumentException("Invalid name.");
                        }
                        //If new user group.
                        if (it.Id == 0)
                        {
                            it.Added = DateTime.Now.ToUniversalTime();
                            Db.Insert(it);
#if !SS4
                            it.Id = Db.GetLastInsertId();
#else
                            it.Id = Db.LastInsertId();
#endif                            
                            //Add adder to user group if adder is not super admin.
                            if (!superAdmin)
                            {
                                GXAmiUserGroupUser g = new GXAmiUserGroupUser();
                                g.UserID = Convert.ToInt64(s.Id);
                                g.UserGroupID = it.Id;
                                g.Added = DateTime.Now.ToUniversalTime();
                                Db.Insert(g);
                            }
                            events.Add(new GXEventsItem(ActionTargets.UserGroup, Actions.Add, it));
                        }
                        else //Update user group.
                        {
                            if (!superAdmin)
                            {
                                //User can't update user data if he do not have access to the user group.
                                long[] groups1 = GXUserGroupService.GetUserGroups(Db, adderId);
                                long[] groups2 = GXUserGroupService.GetUserGroups(Db, it.Id);
                                bool found = false;
                                foreach (long it1 in groups1)
                                {
                                    foreach (long it2 in groups2)
                                    {
                                        if (it1 == it2)
                                        {
                                            found = true;
                                            break;
                                        }
                                    }
                                    if (found)
                                    {
                                        break;
                                    }
                                }
                                if (!found)
                                {
                                    throw new ArgumentException("Access denied.");
                                }
                            }
                            //Get Added time.
#if !SS4
                            GXAmiUserGroup orig = Db.GetById<GXAmiUserGroup>(it.Id);
#else
                            GXAmiUserGroup orig = Db.SingleById<GXAmiUserGroup>(it.Id);                            
#endif                            
                            it.Added = orig.Added.ToUniversalTime();
                            Db.Update(it);
                            events.Add(new GXEventsItem(ActionTargets.UserGroup, Actions.Edit, it));
                        }
                    }
                    trans.Commit();
                }
            }
            AppHost host = this.ResolveService<AppHost>();
            host.SetEvents(Db, this.Request, adderId, events);
            return new GXUserGroupUpdateResponse(request.UserGroups);
        }
 /// <summary>
 /// Add users to user groups.
 /// </summary>
 /// <param name="request"></param>
 /// <returns></returns>
 public GXAddUserToUserGroupResponse Post(GXAddUserToUserGroupRequest request)
 {
     IAuthSession s = this.GetSession(false);
     //Normal user can't change user group name or add new one.
     if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
     {
         throw new ArgumentException("Access denied.");
     }
     long adderId = Convert.ToInt64(s.Id);
     List<GXEventsItem> events = new List<GXEventsItem>();
     lock (Db)
     {
         using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
         {
             bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
             foreach (long user in request.Users)
             {
                 foreach (long group in request.Groups)
                 {
                     if (!superAdmin)
                     {
                         //User can't update user data if he do not have access to the user group.
                         long[] groups1 = GXUserGroupService.GetUserGroups(Db, adderId);
                         long[] groups2 = GXUserGroupService.GetUserGroups(Db, group);
                         bool found = false;
                         foreach (long it1 in groups1)
                         {
                             foreach (long it2 in groups2)
                             {
                                 if (it1 == it2)
                                 {
                                     found = true;
                                     break;
                                 }
                             }
                             if (found)
                             {
                                 break;
                             }
                         }
                         if (!found)
                         {
                             throw new ArgumentException("Access denied.");
                         }
                     }
                     GXAmiUserGroupUser it = new GXAmiUserGroupUser();
                     it.UserGroupID = group;
                     it.UserID = user;
                     it.Added = DateTime.Now.ToUniversalTime();
                     Db.Insert(it);
                     events.Add(new GXEventsItem(ActionTargets.UserGroup, Actions.Edit, it));
                 }
             }
             trans.Commit();
         }
     }
     AppHost host = this.ResolveService<AppHost>();
     host.SetEvents(Db, this.Request, adderId, events);
     return new GXAddUserToUserGroupResponse();
 }
Exemple #3
0
        /// <summary>
        /// Create default tables and set initial settings.
        /// </summary>
        /// <param name="Db"></param>
        static public void InitializeDB(IDbConnection Db, ProgressEventHandler progress, string userName, string password)
        {
            lock (Db)
            {
                try
                {
                    int index = 0;
                    CreateTable <GXAmiSettings>(Db, ref index, progress);
                    CreateTable <GXAmiUser>(Db, ref index, progress);
                    CreateTable <GXAmiUserGroup>(Db, ref index, progress);
                    CreateTable <GXAmiUserGroupUser>(Db, ref index, progress);
                    CreateTable <GXAmiDeviceGroup>(Db, ref index, progress);
                    CreateTable <GXAmiDeviceProfile>(Db, ref index, progress);
                    CreateTable <GXAmiDevice>(Db, ref index, progress);
                    CreateTable <GXAmiMediaType>(Db, ref index, progress);
                    CreateTable <GXAmiDeviceGroup>(Db, ref index, progress);
                    CreateTable <GXAmiUserGroupDeviceGroup>(Db, ref index, progress);
                    CreateTable <GXAmiDeviceGroupDevice>(Db, ref index, progress);
                    CreateTable <GXAmiParameterTemplate>(Db, ref index, progress);
                    CreateTable <GXAmiParameter>(Db, ref index, progress);
                    CreateTable <GXAmiPropertyTemplate>(Db, ref index, progress);
                    CreateTable <GXAmiProperty>(Db, ref index, progress);
                    CreateTable <GXAmiValueItem>(Db, ref index, progress);
                    CreateTable <GXAmiCategoryTemplate>(Db, ref index, progress);
                    CreateTable <GXAmiCategory>(Db, ref index, progress);
                    CreateTable <GXAmiDataTableTemplate>(Db, ref index, progress);
                    CreateTable <GXAmiDataTable>(Db, ref index, progress);
                    CreateTable <GXAmiDataRow>(Db, ref index, progress);
                    CreateTable <GXAmiUserGroupDeviceProfile>(Db, ref index, progress);
                    CreateTable <GXAmiDataCollector>(Db, ref index, progress);
                    CreateTable <GXAmiDataCollectorUserGroup>(Db, ref index, progress);
                    CreateTable <GXAmiTask>(Db, ref index, progress);
                    CreateTable <GXAmiTaskLog>(Db, ref index, progress);
                    CreateTable <GXAmiSystemError>(Db, ref index, progress);
                    CreateTable <GXAmiDeviceError>(Db, ref index, progress);
                    CreateTable <GXAmiUserActionLog>(Db, ref index, progress);
                    CreateTable <GXAmiDeviceProfilesDataBlock>(Db, ref index, progress);
                    CreateTable <GXAmiLatestValue>(Db, ref index, progress);
                    CreateTable <GXAmiValueLog>(Db, ref index, progress);
                    CreateTable <GXAmiSchedule>(Db, ref index, progress);
                    CreateTable <GXAmiScheduleTarget>(Db, ref index, progress);
                    CreateTable <GXAmiDataCollectorParameter>(Db, ref index, progress);
                    CreateTable <GXAmiDataCollectorError>(Db, ref index, progress);
                    CreateTable <GXAmiTaskData>(Db, ref index, progress);
                    CreateTable <GXAmiTaskLogData>(Db, ref index, progress);
                    CreateTable <GXAmiTrace>(Db, ref index, progress);
                    CreateTable <GXAmiTraceData>(Db, ref index, progress);
                    CreateTable <GXAmiDeviceMedia>(Db, ref index, progress);
                    CreateTable <GXAmiVisualizer>(Db, ref index, progress);
                    //Do not change settings values because they are unique.
                    Db.Insert(new GXAmiSettings("DeviceID", "0"));
                    Db.Insert(new GXAmiSettings("Version", "6"));
                    if (progress != null)
                    {
                        progress(++index, 40);
                    }

                    GXAmiUserGroup ug = new GXAmiUserGroup("SuperAdmins");
                    ug.Added = DateTime.Now.ToUniversalTime();
                    GXAmiUser user = new GXAmiUser(userName, password, UserAccessRights.SuperAdmin);
                    user.Added        = DateTime.Now.ToUniversalTime();
                    user.AccessRights = UserAccessRights.SuperAdmin;
                    Db.Insert(ug);
#if !SS4
                    ug.Id = Db.GetLastInsertId();
#else
                    ug.Id = Db.LastInsertId();
#endif
                    Db.Insert(user);
#if !SS4
                    user.Id = Db.GetLastInsertId();
#else
                    user.Id = Db.LastInsertId();
#endif
                    GXAmiUserGroupUser u = new GXAmiUserGroupUser();
                    u.Added       = DateTime.Now.ToUniversalTime();
                    u.UserID      = user.Id;
                    u.UserGroupID = ug.Id;
                    Db.Insert(u);
                    if (progress != null)
                    {
                        progress(0, 0);
                    }
                }
                catch (Exception ex)
                {
                    DropTables(Db);
                    throw ex;
                }
            }
        }
        /// <summary>
        /// Add or update new user group.
        /// </summary>
        public GXUserGroupUpdateResponse Put(GXUserGroupUpdateRequest request)
        {
            IAuthSession s = this.GetSession(false);

            //Normal user can't change user group name or add new one.
            if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
            {
                throw new ArgumentException("Access denied.");
            }
            long adderId = Convert.ToInt64(s.Id);
            List <GXEventsItem> events = new List <GXEventsItem>();

            lock (Db)
            {
                using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
                {
                    bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
                    //Add new user groups
                    foreach (GXAmiUserGroup it in request.UserGroups)
                    {
                        if (string.IsNullOrEmpty(it.Name))
                        {
                            throw new ArgumentException("Invalid name.");
                        }
                        //If new user group.
                        if (it.Id == 0)
                        {
                            it.Added = DateTime.Now.ToUniversalTime();
                            Db.Insert(it);
#if !SS4
                            it.Id = Db.GetLastInsertId();
#else
                            it.Id = Db.LastInsertId();
#endif
                            //Add adder to user group if adder is not super admin.
                            if (!superAdmin)
                            {
                                GXAmiUserGroupUser g = new GXAmiUserGroupUser();
                                g.UserID      = Convert.ToInt64(s.Id);
                                g.UserGroupID = it.Id;
                                g.Added       = DateTime.Now.ToUniversalTime();
                                Db.Insert(g);
                            }
                            events.Add(new GXEventsItem(ActionTargets.UserGroup, Actions.Add, it));
                        }
                        else //Update user group.
                        {
                            if (!superAdmin)
                            {
                                //User can't update user data if he do not have access to the user group.
                                long[] groups1 = GXUserGroupService.GetUserGroups(Db, adderId);
                                long[] groups2 = GXUserGroupService.GetUserGroups(Db, it.Id);
                                bool   found   = false;
                                foreach (long it1 in groups1)
                                {
                                    foreach (long it2 in groups2)
                                    {
                                        if (it1 == it2)
                                        {
                                            found = true;
                                            break;
                                        }
                                    }
                                    if (found)
                                    {
                                        break;
                                    }
                                }
                                if (!found)
                                {
                                    throw new ArgumentException("Access denied.");
                                }
                            }
                            //Get Added time.
#if !SS4
                            GXAmiUserGroup orig = Db.GetById <GXAmiUserGroup>(it.Id);
#else
                            GXAmiUserGroup orig = Db.SingleById <GXAmiUserGroup>(it.Id);
#endif
                            it.Added = orig.Added.ToUniversalTime();
                            Db.Update(it);
                            events.Add(new GXEventsItem(ActionTargets.UserGroup, Actions.Edit, it));
                        }
                    }
                    trans.Commit();
                }
            }
            AppHost host = this.ResolveService <AppHost>();
            host.SetEvents(Db, this.Request, adderId, events);
            return(new GXUserGroupUpdateResponse(request.UserGroups));
        }
        /// <summary>
        /// Add users to user groups.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public GXAddUserToUserGroupResponse Post(GXAddUserToUserGroupRequest request)
        {
            IAuthSession s = this.GetSession(false);

            //Normal user can't change user group name or add new one.
            if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
            {
                throw new ArgumentException("Access denied.");
            }
            long adderId = Convert.ToInt64(s.Id);
            List <GXEventsItem> events = new List <GXEventsItem>();

            lock (Db)
            {
                using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
                {
                    bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);
                    foreach (long user in request.Users)
                    {
                        foreach (long group in request.Groups)
                        {
                            if (!superAdmin)
                            {
                                //User can't update user data if he do not have access to the user group.
                                long[] groups1 = GXUserGroupService.GetUserGroups(Db, adderId);
                                long[] groups2 = GXUserGroupService.GetUserGroups(Db, group);
                                bool   found   = false;
                                foreach (long it1 in groups1)
                                {
                                    foreach (long it2 in groups2)
                                    {
                                        if (it1 == it2)
                                        {
                                            found = true;
                                            break;
                                        }
                                    }
                                    if (found)
                                    {
                                        break;
                                    }
                                }
                                if (!found)
                                {
                                    throw new ArgumentException("Access denied.");
                                }
                            }
                            GXAmiUserGroupUser it = new GXAmiUserGroupUser();
                            it.UserGroupID = group;
                            it.UserID      = user;
                            it.Added       = DateTime.Now.ToUniversalTime();
                            Db.Insert(it);
                            events.Add(new GXEventsItem(ActionTargets.UserGroup, Actions.Edit, it));
                        }
                    }
                    trans.Commit();
                }
            }
            AppHost host = this.ResolveService <AppHost>();

            host.SetEvents(Db, this.Request, adderId, events);
            return(new GXAddUserToUserGroupResponse());
        }
        /// <summary>
        /// Delete selected user.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public GXUserDeleteResponse Post(GXUserDeleteRequest request)
        {
            IAuthSession s  = this.GetSession(false);
            int          id = Convert.ToInt32(s.Id);

            if (id == 0)
            {
                throw new ArgumentException("Remove failed. Invalid session ID.");
            }
            if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
            {
                throw new ArgumentException("Remove not allowed.");
            }
            List <GXEventsItem> events = new List <GXEventsItem>();
            bool superAdmin            = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);

            lock (Db)
            {
                foreach (int it in request.UserIDs)
                {
                    if (it == 0)
                    {
                        throw new ArgumentException("ID is required");
                    }
                    if (!superAdmin && !GXUserGroupService.CanAccess(Db, id, it))
                    {
                        throw new ArgumentException("Access denied.");
                    }
#if !SS4
                    GXAmiUser user = Db.QueryById <GXAmiUser>(it);
#else
                    GXAmiUser user = Db.SingleById <GXAmiUser>(it);
#endif
                    //Remove user from the user group.
                    if (request.GroupIDs != null && request.GroupIDs.Length != 0)
                    {
                        foreach (long gid in request.GroupIDs)
                        {
                            if (!superAdmin)
                            {
                                List <GXAmiUser> list = GetUsers(s, Db, 0, gid, false, false, null, SearchOperator.None, SearchType.All);
                                if (list.Count == 1)
                                {
                                    throw new ArgumentException("Remove not allowed.");
                                }
                            }
                            string             query = string.Format("UserGroupID = {0} AND UserID = {1}", gid, it);
                            GXAmiUserGroupUser item  = Db.Select <GXAmiUserGroupUser>(query)[0];
                            Db.Delete <GXAmiUserGroupUser>(item);
#if !SS4
                            GXAmiUserGroup ug = Db.QueryById <GXAmiUserGroup>(gid);
#else
                            GXAmiUserGroup ug = Db.SingleById <GXAmiUserGroup>(gid);
#endif
                            events.Add(new GXEventsItem(ActionTargets.User, Actions.Edit, user));
                            events.Add(new GXEventsItem(ActionTargets.User, Actions.Edit, ug));
                        }
                    }
                    else //Remove user.
                    {
                        // You can not delete yourself.
                        if (it == id)
                        {
                            throw new ArgumentException("Remove not allowed.");
                        }
                        if (request.Permanently)
                        {
                            Db.DeleteById <GXAmiUser>(it);
                        }
                        else
                        {
                            user.Removed = DateTime.Now.ToUniversalTime();
                            Db.UpdateOnly(user, p => p.Removed, p => p.Id == it);
                        }
                        events.Add(new GXEventsItem(ActionTargets.User, Actions.Remove, user));
                        //Remove all user groups of the user.
                        long[] list = GXUserGroupService.GetUserGroups(Db, it);

                        //TODO: Remove only if last user.
                        foreach (long gid in list)
                        {
#if !SS4
                            GXAmiUserGroup ug = Db.QueryById <GXAmiUserGroup>(gid);
#else
                            GXAmiUserGroup ug = Db.SingleById <GXAmiUserGroup>(gid);
#endif
                            if (request.Permanently)
                            {
                                Db.DeleteById <GXAmiUserGroup>(gid);
                            }
                            else
                            {
                                ug.Removed = DateTime.Now.ToUniversalTime();
                                Db.UpdateOnly(ug, p => p.Removed, p => p.Id == gid);
                            }
                            events.Add(new GXEventsItem(ActionTargets.User, Actions.Edit, user));
                            events.Add(new GXEventsItem(ActionTargets.User, Actions.Edit, ug));
                        }
                    }
                }
            }
            AppHost host = this.ResolveService <AppHost>();
            host.SetEvents(Db, this.Request, id, events);
            return(new GXUserDeleteResponse());
        }