Merge pull request #324 from jeffreykirchner/dev

Dev

main/consumers/staff/session_consumer_mixins/subject_updates.py

@@ -1567,7 +1567,150 @@ async def update_hat_avatar_cancel(self, event):
 
         await self.send_message(message_to_self=event_data, message_to_group=None,
                                 message_type=event['type'], send_to_client=True, send_to_group=False)
+
+    async def group_gate_access_request(self, event):
+        '''
+        request access to group gate
+        '''
+
+        if self.controlling_channel != self.channel_name:
+            return
+
+        logger = logging.getLogger(__name__)
+        # logger.info(event)
+
+        status = "success"
+        error_mesage = ""
 
+        try:
+            session = await Session.objects.aget(id=self.session_id)
+            player_id = self.session_players_local[event["player_key"]]["id"]     
+            group_gate_id = event["message_text"]["group_gate_id"]   
+
+        except:
+            logger.info(f"group_gate_access_request: invalid data, {event['message_text']}")
+            status = "fail"
+            error_mesage = "Access denied."
+
+        group_gate = self.world_state_local['group_gates'][str(group_gate_id)]
+        parameter_set_group_gate = self.parameter_set_local["parameter_set_group_gates"][str(group_gate_id)]
+        session_player = self.world_state_avatars_local['session_players'][str(player_id)]
+        parameter_set_player = self.parameter_set_local["parameter_set_players"][str(session_player["parameter_set_player_id"])]
+
+        #check if player already allowed through a gate
+        for i in self.world_state_local['group_gates']:
+            if player_id in self.world_state_local['group_gates'][i]["allowed_players"]:
+                status = "fail"
+                error_mesage = "You already have access to a gate."
+                return
+
+        #check if player is in allowed group
+        if parameter_set_player["parameter_set_group"] not in parameter_set_group_gate["parameter_set_allowed_groups"]:
+            status = "fail"
+            error_mesage = "You group does not have access."
+            return
+
+        #check already at max for group access
+        group_counter = 0
+        for i in group_gate["allowed_players"]:
+            temp_parameter_set_player = self.world_state_avatars_local['session_players'][str(i)]["parameter_set_player_id"]
+
+            if self.parameter_set_local["parameter_set_players"][str(temp_parameter_set_player)]["parameter_set_group"] == parameter_set_player["parameter_set_group"]:
+                group_counter += 1
+
+        if group_counter >= parameter_set_group_gate["max_players_per_group"]:
+            status = "fail"
+            error_mesage = "Max players reached."
+            return
+
+        if status == "success":
+            group_gate["allowed_players"].append(player_id)
+            await Session.objects.filter(id=self.session_id).aupdate(world_state=self.world_state_local)
+
+        result = {"status" : status, 
+                  "error_message" : error_mesage,
+                  "player_id" : player_id,
+                  "group_gate_id" : group_gate_id,
+                  "group_gate" : group_gate}
+
+        await SessionEvent.objects.acreate(session_id=self.session_id, 
+                                           session_player_id=player_id,
+                                           type="group_gate_access_request",
+                                           period_number=self.world_state_local["current_period"],
+                                           time_remaining=self.world_state_local["time_remaining"],
+                                           data=result)
+
+        # await self.send_message(message_to_self=None, message_to_group=result,
+        #                         message_type=event['type'], send_to_client=False, send_to_group=True)
+
+    async def update_group_gate_access_request(self, event):
+        '''
+        subject update group gate access request
+        '''
+
+        event_data = event["group_data"]
+
+        await self.send_message(message_to_self=event_data, message_to_group=None,
+                                message_type=event['type'], send_to_client=True, send_to_group=False)
+
+    async def group_gate_access_revoke(self, event):
+        '''
+        revoke access to group gate
+        '''
+
+        if self.controlling_channel != self.channel_name:
+            return
+
+        logger = logging.getLogger(__name__)
+        # logger.info(event)
+
+        status = "success"
+        error_mesage = ""
+
+        try:
+            session = await Session.objects.aget(id=self.session_id)
+            player_id = self.session_players_local[event["player_key"]]["id"]     
+            # group_gate_id = event["message_text"]["group_gate_id"]   
+
+        except:
+            logger.info(f"group_gate_access_revoke: invalid data, {event['message_text']}")
+            status = "fail"
+            error_mesage = "Not found."
+
+        for i in self.world_state_local['group_gates']:
+            group_gate = self.world_state_local['group_gates'][i]
+            if player_id in group_gate["allowed_players"]:
+                try:
+                    group_gate["allowed_players"].remove(player_id)
+                except ValueError:
+                    pass
+
+        await Session.objects.filter(id=self.session_id).aupdate(world_state=self.world_state_local)
+
+        result = {"status" : status, 
+                  "error_message" : error_mesage,
+                  "player_id" : player_id,}
+
+        await SessionEvent.objects.acreate(session_id=self.session_id, 
+                                           session_player_id=player_id,
+                                           type="group_gate_access_revoke",
+                                           period_number=self.world_state_local["current_period"],
+                                           time_remaining=self.world_state_local["time_remaining"],
+                                           data=result)
+
+        # await self.send_message(message_to_self=None, message_to_group=result,
+        #                         message_type=event['type'], send_to_client=False, send_to_group=True)
+
+    async def update_group_gate_access_revoke(self, event):
+        '''
+        subject update group gate access revoke
+        '''
+
+        event_data = event["group_data"]
+
+        await self.send_message(message_to_self=event_data, message_to_group=None,
+                                message_type=event['type'], send_to_client=True, send_to_group=False)
+
 def sync_field_harvest(session_id, player_id, field_id, good_one_harvest, good_two_harvest, parameter_set):
     '''
     harvest from field

main/consumers/staff/session_consumer_mixins/timer.py

@@ -90,6 +90,7 @@ async def continue_timer(self, event):
             result["current_experiment_phase"] = self.world_state_local["current_experiment_phase"]
             result["period_is_over"] = v["period_is_over"]
             result["avatars"] = self.world_state_local["avatars"]
+            result["group_gates"] = self.world_state_local["group_gates"]
 
             if v["period_is_over"]:
 
@@ -307,6 +308,12 @@ def sync_continue_timer(event, session_id, world_state, parameter_set):
                 for k in main.globals.Goods.choices:                       
                     sd_player["house_" + k[0]] = world_state["houses"][str(avatar["parameter_set_player_id"])][k[0]]
                     sd_player["avatar_" + k[0]] =  avatar[k[0]]
+
+                #store group gates
+                for k in world_state["group_gates"]:
+                    group_gate = world_state["group_gates"][k]
+                    if int(i) in group_gate["allowed_players"]:
+                        sd_player["group_gate_" + k] = True
 
             last_period.save()
 

main/consumers/staff/session_parameters_consumer_mixins/__init__.py

@@ -8,5 +8,6 @@
 from .parameter_set_groups import ParameterSetGroupsMixin
 from .parameter_set_notices import ParameterSetNoticesMixin
 from .parameter_set_barriers import ParameterSetBarriersMixin
+from .parameter_set_group_gates import ParameterSetGroupGatesMixin
 from .parameter_set_patches import ParameterSetPatchesMixin
 from .parameter_set_hats import ParameterSetHatsMixin

main/consumers/staff/session_parameters_consumer_mixins/parameter_set_grounds.py

@@ -76,7 +76,7 @@ def take_update_parameter_set_ground(data):
     logger.info(f'form_data_dict : {form_data_dict}')
 
     form = ParameterSetGroundForm(form_data_dict, instance=parameter_set_ground)
-    form.fields["parameter_set_group"].queryset = session.parameter_set.parameter_set_groups.all()
+    form.fields["parameter_set_group"].queryset = session.parameter_set.parameter_set_groups.all()    
 
     if form.is_valid():         
         form.save()              

main/consumers/staff/session_parameters_consumer_mixins/parameter_set_group_gates.py

@@ -0,0 +1,135 @@
+import logging
+
+from asgiref.sync import sync_to_async
+
+from django.core.exceptions import ObjectDoesNotExist
+
+from main.models import Session
+from main.models import ParameterSetGroupGate
+
+from main.forms import ParameterSetGroupGateForm
+
+from ..session_parameters_consumer_mixins.get_parameter_set import take_get_parameter_set
+
+class ParameterSetGroupGatesMixin():
+    '''
+    parameter set plaeyer mixin
+    '''
+
+    async def update_parameter_set_group_gate(self, event):
+        '''
+        update a parameterset group_gate
+        '''
+
+        message_data = {}
+        message_data["status"] = await take_update_parameter_set_group_gate(event["message_text"])
+        message_data["parameter_set"] = await take_get_parameter_set(event["message_text"]["session_id"])
+
+        await self.send_message(message_to_self=message_data, message_to_group=None,
+                                message_type="update_parameter_set", send_to_client=True, send_to_group=False)
+
+    async def remove_parameterset_group_gate(self, event):
+        '''
+        remove a parameterset group_gate
+        '''
+
+        message_data = {}
+        message_data["status"] = await take_remove_parameterset_group_gate(event["message_text"])
+        message_data["parameter_set"] = await take_get_parameter_set(event["message_text"]["session_id"])
+
+        await self.send_message(message_to_self=message_data, message_to_group=None,
+                                message_type="update_parameter_set", send_to_client=True, send_to_group=False)
+
+    async def add_parameterset_group_gate(self, event):
+        '''
+        add a parameterset group_gate
+        '''
+
+        message_data = {}
+        message_data["status"] = await take_add_parameterset_group_gate(event["message_text"])
+        message_data["parameter_set"] = await take_get_parameter_set(event["message_text"]["session_id"])
+
+        await self.send_message(message_to_self=message_data, message_to_group=None,
+                                message_type="update_parameter_set", send_to_client=True, send_to_group=False)
+
+@sync_to_async
+def take_update_parameter_set_group_gate(data):
+    '''
+    update parameterset group_gate
+    '''   
+    logger = logging.getLogger(__name__) 
+    logger.info(f"Update parameterset group_gate: {data}")
+
+    session_id = data["session_id"]
+    parameterset_group_gate_id = data["parameterset_group_gate_id"]
+    form_data = data["form_data"]
+
+    try:        
+        session = Session.objects.get(id=session_id)
+        parameter_set_group_gate = ParameterSetGroupGate.objects.get(id=parameterset_group_gate_id)
+    except ObjectDoesNotExist:
+        logger.warning(f"take_update_parameter_set_group_gate parameterset_group_gate, not found ID: {parameterset_group_gate_id}")
+        return
+
+    form_data_dict = form_data
+
+    logger.info(f'form_data_dict : {form_data_dict}')
+
+    form = ParameterSetGroupGateForm(form_data_dict, instance=parameter_set_group_gate)
+    form.fields["parameter_set_allowed_groups"].queryset = session.parameter_set.parameter_set_groups.all()
+    form.fields["parameter_set_ground"].queryset = session.parameter_set.parameter_set_grounds.all()
+
+    if form.is_valid():         
+        form.save()              
+        parameter_set_group_gate.parameter_set.update_json_fk(update_group_gates=True)
+
+        return {"value" : "success"}                      
+
+    logger.info("Invalid parameterset group_gate form")
+    return {"value" : "fail", "errors" : dict(form.errors.items())}
+
+@sync_to_async
+def take_remove_parameterset_group_gate(data):
+    '''
+    remove the specifed parmeterset group_gate
+    '''
+    logger = logging.getLogger(__name__) 
+    logger.info(f"Remove parameterset group_gate: {data}")
+
+    session_id = data["session_id"]
+    parameterset_group_gate_id = data["parameterset_group_gate_id"]
+
+    try:        
+        session = Session.objects.get(id=session_id)
+        parameter_set_group_gate = ParameterSetGroupGate.objects.get(id=parameterset_group_gate_id)
+
+    except ObjectDoesNotExist:
+        logger.warning(f"take_remove_parameterset_group_gate, not found ID: {parameterset_group_gate_id}")
+        return
+
+    parameter_set_group_gate.delete()
+    session.parameter_set.update_json_fk(update_group_gates=True)
+
+    return {"value" : "success"}
+
+@sync_to_async
+def take_add_parameterset_group_gate(data):
+    '''
+    add a new parameter group_gate to the parameter set
+    '''
+    logger = logging.getLogger(__name__) 
+    logger.info(f"Add parameterset group_gate: {data}")
+
+    session_id = data["session_id"]
+
+    try:        
+        session = Session.objects.get(id=session_id)
+    except ObjectDoesNotExist:
+        logger.warning(f"take_add_parameterset_group_gate session, not found ID: {session_id}")
+        return {"value" : "fail"}
+
+    parameter_set_group_gate = ParameterSetGroupGate.objects.create(parameter_set=session.parameter_set)
+    session.parameter_set.update_json_fk(update_group_gates=True)
+
+    return {"value" : "success"}
+

main/consumers/staff/staff_session_parameters_consumer.py

@@ -17,6 +17,7 @@ class StaffSessionParametersConsumer(SocketConsumerMixin,
                                      ControlParameterSetMixin,
                                      ParameterSetNoticesMixin,
                                      ParameterSetBarriersMixin,
+                                     ParameterSetGroupGatesMixin,
                                      ParameterSetPatchesMixin,
                                      ParameterSetHatsMixin,
                                      SendMessageMixin):

main/consumers/subject/subject_home_consumer_mixins/interface.py

@@ -182,6 +182,26 @@ async def update_hat_avatar_cancel(self, event):
 
         await self.send_message(message_to_self=event_data, message_to_subjects=None, message_to_staff=None, 
                                 message_type=event['type'], send_to_client=True, send_to_group=False)
+
+    async def update_group_gate_access_request(self, event):
+        '''
+        request gate access
+        '''
+
+        event_data = event["group_data"]
+
+        await self.send_message(message_to_self=event_data, message_to_subjects=None, message_to_staff=None, 
+                                message_type=event['type'], send_to_client=True, send_to_group=False)
+
+    async def update_group_gate_access_revoke(self, event):
+        '''
+        remove gate access
+        '''
+
+        event_data = event["group_data"]
+
+        await self.send_message(message_to_self=event_data, message_to_subjects=None, message_to_staff=None, 
+                                message_type=event['type'], send_to_client=True, send_to_group=False)
 
 
 

main/forms/__init__.py

@@ -19,6 +19,7 @@
 from .parameter_set_barrier_form import ParameterSetBarrierForm
 from .parameter_set_patch_form import ParameterSetPatchForm
 from .parameter_set_hat_form import ParameterSetHatForm
+from .parameter_set_group_gate_form import ParameterSetGroupGateForm
 
 from .session_player_name_etc_form import StaffEditNameEtcForm