/// <summary>
        /// Add or update device group.
        /// </summary>
        public GXDeviceGroupUpdateResponse Put(GXDeviceGroupUpdateRequest request)
        {
            List <GXEventsItem> events = new List <GXEventsItem>();
            IAuthSession        s      = this.GetSession(false);

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

            lock (Db)
            {
                using (var trans = Db.OpenTransaction(IsolationLevel.ReadCommitted))
                {
                    //Add new device groups
                    foreach (GXAmiDeviceGroup it in request.Items)
                    {
                        if (string.IsNullOrEmpty(it.Name))
                        {
                            throw new ArgumentException("Invalid name.");
                        }
                        //If new device group.
                        if (it.Id == 0)
                        {
                            it.Id    = GXAmiSettings.GetNewDeviceID(Db);
                            it.Added = DateTime.Now.ToUniversalTime();
                            Db.Insert(it);
                            events.Add(new GXEventsItem(ActionTargets.DeviceGroup, Actions.Add, it));
                        }
                        else //Update device group.
                        {
                            //Get Added time.
#if !SS4
                            GXAmiDeviceGroup orig = Db.GetById <GXAmiDeviceGroup>(it.Id);
#else
                            GXAmiDeviceGroup orig = Db.SingleById <GXAmiDeviceGroup>(it.Id);
#endif
                            it.Added = orig.Added;
                            Db.Update(it);
                            events.Add(new GXEventsItem(ActionTargets.DeviceGroup, Actions.Edit, it));
                        }
                    }
                    trans.Commit();
                }
            }
            AppHost host = this.ResolveService <AppHost>();
            host.SetEvents(Db, this.Request, adderId, events);
            return(new GXDeviceGroupUpdateResponse(request.Items));
        }
        /// <summary>
        /// Delete selected device group.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public GXDeviceGroupDeleteResponse Post(GXDeviceGroupDeleteRequest request)
        {
            IAuthSession s = this.GetSession(false);
            //Normal user can't remove device group.
            bool superAdmin = GuruxAMI.Server.GXBasicAuthProvider.IsSuperAdmin(s);

            if (!GuruxAMI.Server.GXBasicAuthProvider.CanUserEdit(s))
            {
                throw new ArgumentException("Access denied.");
            }

            long id = Convert.ToInt64(s.Id);
            List <GXEventsItem> events = new List <GXEventsItem>();

            lock (Db)
            {
                foreach (ulong it in request.DeviceGroupIDs)
                {
                    if (it == 0)
                    {
                        throw new ArgumentException("ID is required");
                    }
                    if (!superAdmin && !CanUserAccessDeviceGroup(Db, id, it))
                    {
                        throw new ArgumentException("Access denied.");
                    }
#if !SS4
                    GXAmiDeviceGroup dg = Db.QueryById <GXAmiDeviceGroup>(it);
#else
                    GXAmiDeviceGroup dg = Db.SingleById <GXAmiDeviceGroup>(it);
#endif
                    if (request.Permanently)
                    {
                        Db.DeleteById <GXAmiDeviceGroup>(it);
                    }
                    else
                    {
                        dg.Removed = DateTime.Now.ToUniversalTime();
                        Db.UpdateOnly(dg, p => p.Removed, p => p.Id == it);
                    }
                    events.Add(new GXEventsItem(ActionTargets.DeviceGroup, Actions.Remove, dg));
                }
            }
            AppHost host = this.ResolveService <AppHost>();
            host.SetEvents(Db, this.Request, id, events);
            return(new GXDeviceGroupDeleteResponse());
        }
示例#3
0
        void HandleDeviceGroup(IDbConnection Db, GXAmiDeviceGroup group, GXEventsItem e)
        {
            ulong mask = (ulong)((int)e.Target << 16 | (int)e.Action);

            //Find is anyone interested from this device group event.
            lock (Db)
            {
                foreach (GXSession it in Sessions)
                {
                    foreach (GXEvent e1 in it.NotifyClients)
                    {
                        if (e1.UserID != 0 && (mask & e1.Mask) != 0)
                        {
                            //Notify only super admin and if user has access to this device group.
                            if (e1.SuperAdmin || GXDeviceGroupService.CanUserAccessDeviceGroup(Db, e1.UserID, group.Id))
                            {
                                e1.Rows.Add(e);
                                it.Received.Set();
                            }
                        }
                    }
                }
            }
        }
		public GXDeviceGroupResponse(GXAmiDeviceGroup[] groups)
		{
			this.DeviceGroups = groups;
		}
示例#5
0
 void Client_OnDeviceGroupsAdded(object sender, GXAmiDeviceGroup[] deviceGrops, GXAmiDeviceGroup group)
 {
     throw new NotImplementedException();
 }