def get(self, request, *args, **kwargs): channel_data = self.get_channel_data(*args, **kwargs) chcoll_data: Optional[ChannelCollectionModel] = \ ChannelCollectionManager.get_chcoll_child_channel(channel_data.model.id) root_oid = get_root_oid(request) channel_name = channel_data.model.get_channel_name(root_oid) msgdata_1d = MessageStatsDataProcessor.get_user_channel_messages(channel_data.model, hours_within=24) msgdata_7d = MessageStatsDataProcessor.get_user_channel_messages(channel_data.model, hours_within=168) member_info = InfoProcessor.get_member_info(channel_data.model) return render_template( self.request, _("Channel Info - {}").format(channel_name), "info/channel/main.html", { "channel_name": channel_name, "channel_data": channel_data.model, "chcoll_data": chcoll_data, "user_message_data1d": msgdata_1d, "user_message_data7d": msgdata_7d, "member_info": member_info, "manageable": bool(ProfileManager.get_user_profiles(channel_data.model.id, root_oid)), "bot_usage_7d": BotFeatureUsageDataManager.get_channel_usage(channel_data.model.id, hours_within=168), "bot_usage_all": BotFeatureUsageDataManager.get_channel_usage(channel_data.model.id) }, nav_param=kwargs)
def render_template(request, title, template_name, context=None, content_type=None, status=None, using=None, nav_param=None) -> HttpResponse: if context is None: context = dict() if nav_param is None: nav_param = dict() # Append variable for base template context["title"] = title # Append navigation bar items nav = construct_nav(request, nav_param) context["nav_bar_html"] = nav.to_html() context["nav_bread"] = nav.to_bread() context["static_keys_result"] = result context["static_keys_param"] = param # Append user id vars context["api_token"] = request.COOKIES.get(keys.Cookies.USER_TOKEN) context["root_oid"] = get_root_oid(request) # Append version numbers for footer context["boot_dt"] = timezone.localtime(get_boot_dt()).strftime("%m/%d %H:%M (UTC%z)") return render(request, template_name, context, content_type, status, using)
def process_request(self, request): root_oid = get_root_oid(request) if root_oid is None: timezone.activate(default_locale.to_tzinfo()) else: timezone.activate(RootUserManager.get_tzinfo_root_oid(root_oid))
def get(self, request, *args, **kwargs): keyword = request.GET.get("w") include_inactive = safe_cast(request.GET.get("include_inactive"), bool) channel_data = self.get_channel_data(*args, **kwargs) channel_name = channel_data.model.get_channel_name( get_root_oid(request)) module_list = list( AutoReplyManager.get_conn_list(channel_data.model.id, keyword, not include_inactive)) uids = [] for module in module_list: uids.append(module.creator_oid) if not module.active and module.remover_oid: uids.append(module.remover_oid) username_dict = IdentitySearcher.get_batch_user_name( uids, channel_data.model, on_not_found="") return render_template( request, _("Auto-Reply search in {}").format(channel_name), "ar/search-main.html", { "channel_name": channel_name, "channel_oid": channel_data.model.id, "module_list": module_list, "username_dict": username_dict, "include_inactive": include_inactive, "keyword": keyword or "" }, nav_param=kwargs)
def get(self, request, **kwargs): profile_result = get_profile_data(kwargs) if not profile_result.ok: return WebsiteErrorView.website_error( request, WebsiteError.PROFILE_NOT_FOUND, {"profile_oid": profile_result.oid_org}) root_oid = get_root_oid(request) profile_model = profile_result.model channel_model = ChannelManager.get_channel_oid( profile_model.channel_oid) permissions = ProfileManager.get_user_permissions( channel_model.id, root_oid) # noinspection PyTypeChecker return render_template( request, _("Profile Info - {}").format(profile_model.name), "info/profile.html", { "profile_data": profile_model, "profile_controls": ProfileHelper.get_user_profile_controls( channel_model, profile_model.id, root_oid, permissions), "perm_cats": list(ProfilePermission), "is_default": profile_model.id == channel_model.config.default_profile_oid }, nav_param=kwargs)
def get(self, request, *args, **kwargs): # `kwargs` will be used as `nav_param` so extract channel_oid from `kwargs` instead of creating param. channel_oid_str = kwargs.get("channel_oid", "") channel_oid = safe_cast(channel_oid_str, ObjectId) u_profs = ProfileManager.get_user_profiles(channel_oid, get_root_oid(request)) if u_profs: return render_template( self.request, _("Channel Management - {}").format(channel_oid), "account/channel/manage.html", { "user_profiles": u_profs, "perm_sum": sorted(ProfileManager.get_permissions(u_profs), key=lambda x: x.code), "channel_oid": channel_oid }, nav_param=kwargs) else: c_prof = ChannelManager.get_channel_oid(channel_oid) if c_prof: messages.info( request, _("You are redirected to the channel info page " "because you don't have any connections linked to the channel."), extra_tags="info" ) return redirect(reverse("info.channel", kwargs={"channel_oid": channel_oid})) else: return WebsiteErrorView.website_error( request, WebsiteError.PROFILE_LINK_NOT_FOUND, {"channel_oid": channel_oid_str})
def process_response(self, request, response): api_action = request.session.pop(Session.APIStatisticsCollection.API_ACTION, APIStatisticModel.ApiAction.default_value) dict_response = request.session.pop(Session.APIStatisticsCollection.DICT_RESPONSE, APIStatisticModel.Response.default_value) dict_params = request.session.pop(Session.APIStatisticsCollection.DICT_PARAMS, APIStatisticModel.Parameter.default_value) success = request.session.pop(Session.APIStatisticsCollection.SUCCESS, APIStatisticModel.Success.default_value if dict_params is None else dict_params.get( result.SUCCESS, APIStatisticModel.Success.default_value)) collect = request.session.pop(Session.APIStatisticsCollection.COLLECT, False) path_params = None if request.method == "GET": path_params = request.GET elif request.method == "POST": path_params = request.POST if collect: rec_result = APIStatisticsManager.record_stats( api_action, get_root_oid(request), dict_response, dict_params, success, path_params, request.path_info, request.get_full_path_info() ) if settings.DEBUG and not rec_result.success: if rec_result.exception is None: raise RuntimeError(f"Stats not recorded. Result: {repr(rec_result.serialize())}") else: raise rec_result.exception return response
def get(self, request, *args, **kwargs): root_uid = get_root_oid(request) return render_template( request, _("Add an Auto-Reply module"), "ar/add.html", { "max_responses": AutoReply.MaxResponses, "max_length": AutoReply.MaxContentLength, "platform_list": list(Platform), "contenttype_list_kw": [ t for t in list(AutoReplyContentType) if t != AutoReplyContentType.IMAGE ], "contenttype_list_rep": list(AutoReplyContentType), "tag_splitter": AutoReply.TagSplitter, "user_ch_list": ProfileManager.get_user_channel_profiles( root_uid, inside_only=True, accessbible_only=True), "root_uid_str": str(root_uid), "perm_pin_access": ProfilePermission.AR_ACCESS_PINNED_MODULE.code, "oid_key": OID_KEY })
def post(self, request, *args, **kwargs): if not self.post_response_specified: return HttpResponseNotAllowed(self.allowed_response_classes) else: response_api = self.__class__.post_response_class(request.POST, get_root_oid(request)) return self.process_api_response(request, response_api, *args, **kwargs)
def get(self, request, *args, **kwargs): root_uid = get_root_oid(request) return render_template( request, _("Auto-Reply ranking channel list"), "ar/rk-chlist.html", { "channel_list": ProfileManager.get_user_channel_profiles( root_uid, inside_only=True, accessbible_only=True) }, nav_param=kwargs)
def get(self, request, *args, **kwargs): config = RootUserManager.get_config_root_oid(get_root_oid(request)) return render_template( self.request, _("Account Settings"), "account/settings.html", { "locale_list": sorted(locales, key=lambda item: item.description), "lang_list": sorted(languages, key=lambda item: item.code), "current_config": config })
def get(self, request, *args, **kwargs): keyword = request.GET.get("w", "") channel_list = [] if keyword: channel_list = IdentitySearcher.search_channel(keyword, get_root_oid(request)) return render_template( self.request, _("Channel Info Search"), "info/channel/search.html", {"channel_list": channel_list, "keyword": keyword}, nav_param=kwargs)
def get(self, request, *args, **kwargs): channel_data = self.get_channel_data(*args, **kwargs) hours_within = safe_cast(request.GET.get("hours_within"), int) incl_unav = safe_cast(request.GET.get("incl_unav"), bool) period_count = safe_cast(request.GET.get("period"), int) or Website.Message.DefaultPeriodCount if period_count <= 0: messages.warning(request, _("Period count cannot be less than or equal to 0.")) period_count = Website.Message.DefaultPeriodCount # Get starting timestamp dt_start = self.get_timestamp( request, "start", msg_parse_failed=_("Failed to parse the starting timestamp. Received: {}"), msg_out_of_range=_("Start time out of range.") ) # Get ending timestamp dt_end = self.get_timestamp( request, "end", msg_parse_failed=_("Failed to parse the ending timestamp. Received: {}"), msg_out_of_range=_("End time out of range.") ) # Check starting and ending timestamp if dt_start and dt_end and dt_start > dt_end: dt_start = None dt_end = None messages.warning( request, _("Invalid timestamp: Ending time is before the starting time.")) channel_name = channel_data.model.get_channel_name(get_root_oid(request)) pkg = get_msg_stats_data_package( channel_data.model, get_current_timezone(), incl_unav, hours_within=hours_within, start=dt_start, end=dt_end, period_count=period_count) hours_within = pkg[KEY_MSG_INTV_FLOW].hr_range or hours_within msg_count = pkg[KEY_MSG_USER_CHANNEL].msg_count ctxt = { "channel_name": channel_name, "channel_data": channel_data.model, "hr_range": hours_within, "dt_start": dt_start.replace(tzinfo=None).isoformat() if dt_start else "", "dt_end": dt_end.replace(tzinfo=None).isoformat() if dt_end else "", "message_frequency": (hours_within * 3600) / msg_count if msg_count > 0 else 0, "incl_unav": incl_unav, "period_count": period_count } ctxt.update(pkg) return render_template( self.request, _("Channel Message Stats - {}").format(channel_name), "info/msgstats/main.html", ctxt, nav_param=kwargs)
def process_request(self, request): root_oid = get_root_oid(request) if root_oid: l_code = RootUserManager.get_lang_code_root_oid(root_oid) if l_code: activate(l_code) return deactivate()
def post(self, request, *args, **kwargs): data = get_post_keys(request.POST) root_uid = get_root_oid(request) model = ProfileManager.register_new(root_uid, ProfileManager.process_create_profile_kwargs(data)) if model: messages.info(request, _("Profile successfully created.")) else: messages.warning(request, _("Failed to create the profile.")) return redirect(reverse("info.profile", kwargs={"profile_oid": model.id}))
def post(self, request, *args, **kwargs): update_result = RootUserManager.update_config( get_root_oid(request), **get_post_keys(request.POST)) if update_result.success: return simple_str_response( request, f"success/{localtime(now_utc_aware()):%m-%d %H:%M:%S (%Z)} - " f"{_('Account settings updated.')}") else: return simple_str_response( request, f"danger/{localtime(now_utc_aware()):%m-%d %H:%M:%S (%Z)} - " f"{_('Account settings failed to update.')}")
def get(self, request, *args, **kwargs): channel_result = self.get_channel_data(*args, **kwargs) permissions = ProfileManager.get_user_permissions(channel_result.model.id, get_root_oid(request)) can_ced_profile = ProfilePermission.PRF_CED in permissions return render_template( self.request, _("List Profile"), "account/channel/prof/list.html", { "prof_entry": ProfileHelper.get_channel_profiles(channel_result.model.id), "perm_cats": list(ProfilePermission), "can_ced_profile": can_ced_profile, "channel_oid": channel_result.model.id }, nav_param=kwargs)
def get(self, request, *args, **kwargs): root_oid = get_root_oid(request) channel_data = self.get_channel_data(*args, **kwargs) profiles = ProfileManager.get_user_profiles(channel_data.model.id, root_oid) max_perm_lv = ProfileManager.get_highest_permission_level(profiles) return render_template( self.request, _("Create Profile"), "account/channel/prof/create.html", { "channel_oid": channel_data.model.id, "max_perm_lv": max_perm_lv, "perm_cats_controllable": ProfilePermissionDefault.get_overridden_permissions(max_perm_lv), "perm_cats": list(ProfilePermission), "value_color": ColorFactory.DEFAULT.color_hex }, nav_param=kwargs)
def get(self, request, *args, **kwargs): root_oid = get_root_oid(request) if root_oid and now_utc_aware() - root_oid.generation_time < timedelta( days=Website.NewRegisterThresholdDays): messages.info( request, _('It seems that you haven\'t integrate your account. ' 'Visit <a href="{}{}">this page</a> to know what to do to fully utilize this bot!' ).format( HostUrl, reverse("page.doc.botcmd.cmd", kwargs={"code": cmd_uintg.main_cmd_code})), extra_tags="safe") return render_template(request, _("Home Page"), "index.html")
def dispatch(self, request, *args, **kwargs): root_oid = get_root_oid(request) pass_ = ProfileManager.get_user_permissions(self.get_channel_data(*args, **kwargs).model.id, root_oid)\ .issuperset(self.required_permission()) if not pass_: return WebsiteErrorView.website_error( request, WebsiteError.INSUFFICIENT_PERMISSION, { "channel_oid": self.get_channel_data(*args, ** kwargs).oid_org, "required_permission": self.required_permission() }, nav_param=kwargs) else: return super().dispatch(request, *args, **kwargs)
def get(self, request, *args, **kwargs): root_oid = get_root_oid(request) access_ok = [] access_no = [] for channel_conn in ProfileManager.get_user_channel_profiles(root_oid, accessbible_only=False): if channel_conn.channel_data.bot_accessible: access_ok.append(channel_conn) else: access_no.append(channel_conn) return render_template( self.request, _("Channel List"), "account/channel/list.html", { "conn_access_ok": access_ok, "conn_access_no": access_no, "bot_cmd_info_code": cmd_id.main_cmd_code })
def get(self, request, *args, **kwargs): root_oid = get_root_oid(request) channel_data = self.get_channel_data(*args, **kwargs) channel_oid = channel_data.model.id attach_member = ProfileManager.can_control_profile_member( ProfileManager.get_user_permissions(channel_oid, root_oid)) member_list = {} if attach_member: member_list = IdentitySearcher.get_batch_user_name( ProfileManager.get_channel_member_oids(channel_oid, available_only=True), channel_data.model) member_list = sorted(member_list.items(), key=lambda item: item[1]) return render_template( self.request, _("Attach Profile"), "account/channel/prof/attach.html", { "channel_oid": channel_oid, "attachable_profiles": ProfileManager.get_attachable_profiles(channel_data.model.get_oid(), root_oid), "member_list": member_list }, nav_param=kwargs)
def get(self, request, *args, **kwargs): # `kwargs` will be used as `nav_param` so extract chcoll_oid from `kwargs` instead of creating param. # `chcoll_oid` may be misformatted. # If so, `safe_cast` will yield `None` while the original parameter needs to be kept for the case of not found. chcoll_oid_str = kwargs.get("chcoll_oid", "") chcoll_oid = safe_cast(chcoll_oid_str, ObjectId) chcoll_data: Optional[ ChannelCollectionModel] = ChannelCollectionManager.get_chcoll_oid( chcoll_oid) if not chcoll_data: return WebsiteErrorView.website_error( request, WebsiteError.CHANNEL_COLLECTION_NOT_FOUND, {"chcoll_oid": chcoll_oid_str}, nav_param=kwargs) msgdata_1d = MessageStatsDataProcessor.get_user_chcoll_messages( chcoll_data, hours_within=24) msgdata_7d = MessageStatsDataProcessor.get_user_chcoll_messages( chcoll_data, hours_within=168) return render_template( self.request, _("Channel Collection Info - {}").format(chcoll_oid), "info/chcoll/main.html", { "chcoll_data": chcoll_data, "chcoll_cch_data": InfoProcessor.collate_child_channel_data( get_root_oid(request), chcoll_data.child_channel_oids), "user_message_data1d": msgdata_1d, "user_message_data7d": msgdata_7d }, nav_param=kwargs)
def get(self, request, *args, **kwargs): channel_data = self.get_channel_data(*args, **kwargs) # Check if the user is in the channel root_oid = get_root_oid(request) profs = ProfileManager.get_user_profiles(channel_data.model.id, root_oid) if not profs or profs == ChannelProfileConnectionModel.ProfileOids.none_obj( ): return WebsiteErrorView.website_error( request, WebsiteError.NOT_IN_THE_CHANNEL, {"channel_oid": channel_data.oid_org}, nav_param=kwargs) # Process the necessary data channel_name = channel_data.model.get_channel_name(root_oid) limit = get_limit(request.GET, Website.RecentActivity.MaxMessageCount) ctxt = { "channel_name": channel_name, "channel_data": channel_data.model, "recent_msg_limit": limit or "", "recent_msg_limit_max": Website.RecentActivity.MaxMessageCount, "recent_msg_data": MessageStatsDataProcessor.get_recent_messages( channel_data.model, limit) } return render_template(self.request, _("Recent Messages - {}").format(channel_name), "info/recent/message.html", ctxt, nav_param=kwargs)
def action_delete(request, channel_model, profile_oid): # Terminate if the profile to be deleted is the default profile if channel_model.config.default_profile_oid == profile_oid: messages.warning( request, _("Attempted to delete the default profile which is not allowed." )) return redirect( reverse("info.profile", kwargs={"profile_oid": profile_oid})) # Detach profile from all users and delete the profile from the database deleted = ProfileManager.delete_profile(channel_model.id, profile_oid, get_root_oid(request)) # Alert messages if deleted: messages.info(request, _("Profile deleted.")) return redirect(reverse("account.channel.list")) else: messages.warning(request, _("Failed to delete the profile.")) return redirect( reverse("info.profile", kwargs={"profile_oid": profile_oid}))
def post(self, request, **kwargs): sender_oid = get_root_oid(request) profile_result = get_profile_data(kwargs) if not profile_result.ok: return HttpResponse(status=404) channel_model = ChannelManager.get_channel_oid( profile_result.model.channel_oid) # --- Get form data action = InfoPageActionControl.parse(request.POST.get("action")) target_uid = safe_cast(request.POST.get("uid"), ObjectId) if not action.is_argument_valid(target_uid): return HttpResponse(status=400) # --- Check permission permissions = ProfileManager.get_user_permissions( channel_model.id, sender_oid) # --- Execute corresponding action profile_oid = profile_result.model.id if action == InfoPageActionControl.DETACH: return InfoPageActionControl.action_detach(request, channel_model.id, sender_oid, target_uid, permissions, profile_oid) elif action == InfoPageActionControl.DELETE: return InfoPageActionControl.action_delete(request, channel_model, profile_oid) else: return HttpResponse(status=501)
def get(self, request, *args, **kwargs): channel_data = self.get_channel_data(*args, **kwargs) hours_within = safe_cast(request.GET.get("hours_within"), int) # channel_members = ProfileManager.get_channel_members(channel_oid) # Reserved for per member analysis channel_name = channel_data.model.get_channel_name( get_root_oid(request)) pkg = get_bot_stats_data_package(channel_data.model, hours_within, get_current_timezone()) ctxt = { "channel_name": channel_name, "channel_data": channel_data.model, "hr_range": hours_within or pkg[KEY_HR_FLOW].hr_range } ctxt.update(pkg) return render_template(self.request, _("Bot Usage Stats - {}").format(channel_name), "info/botstats/main.html", ctxt, nav_param=kwargs)
def get(self, request, *args, **kwargs): return render_template( self.request, _("Short URL Service"), "services/shorturl/main.html", {"records": ShortUrlDataManager.get_user_record(get_root_oid(request))})
def test_func(self): return get_root_oid( self.request ) is not None and keys.Cookies.USER_TOKEN in self.request.COOKIES