def update_user_language(user_email: str, language: str):
utils.get_grpc_types().get("flow").update_language(
user_email=user_email,
language=language,
)
IntelligenceRESTClient().update_language(
user_email=user_email,
language=language,
)
return True
def destroy_classifier(classifier_uuid: str, user_email: str):
grpc_instance = utils.get_grpc_types().get("flow")
grpc_instance.delete_classifier(
classifier_uuid=str(classifier_uuid),
user_email=str(user_email),
)
return True
def get_messages(contact_uuid: str, before: str, after: str,
project_uuid: str):
flow_instance = utils.get_grpc_types().get("flow")
contact = Contact.objects.get(uuid=contact_uuid)
project = Project.objects.get(uuid=project_uuid)
message = flow_instance.get_message(str(project.flow_organization),
str(contact.contact_flow_uuid), before,
after)
if len(message.uuid) == 0:
return False
try:
Message.objects.get(message_flow_uuid=message.uuid)
except Message.DoesNotExist:
Message.objects.create(
contact=contact,
text=message.text,
created_on=message.created_on,
direction=message.direction,
message_flow_uuid=message.uuid,
)
channel = Channel.create(
channel_type=message.channel_type,
channel_flow_id=message.channel_id,
project=project,
)
contact.update_channel(channel)
return True
def realease_channel(channel_uuid, user):
grpc_instance = utils.get_grpc_types().get("flow")
grpc_instance.release_channel(
channel_uuid=channel_uuid,
user=user,
)
return True
def update_project(organization_uuid: str, organization_name: str):
grpc_instance = utils.get_grpc_types().get("flow")
grpc_instance.update_project(
organization_uuid=organization_uuid,
organization_name=organization_name,
)
return True
def delete_project(inteligence_organization: int, user_email):
grpc_instance = utils.get_grpc_types().get("flow")
grpc_instance.delete_project(
project_uuid=inteligence_organization,
user_email=user_email,
)
return True
def check_organization_free_plan():
limits = GenericBillingData.get_generic_billing_data_instance()
flow_instance = utils.get_grpc_types().get("flow")
for organization in Organization.objects.filter(
organization_billing__plan="free", is_suspended=False):
for project in organization.project.all():
project_timezone = project.timezone
now = pendulum.now(project_timezone)
before = now.strftime("%Y-%m-%d %H:%M")
# first day of month
after = now.start_of('month').strftime("%Y-%m-%d %H:%M")
contact_count = flow_instance.get_billing_total_statistics(
project_uuid=str(project.flow_organization),
before=before,
after=after).get("active_contacts")
project.contact_count = int(contact_count)
project.save(update_fields=["contact_count"])
current_active_contacts = organization.active_contacts
if current_active_contacts > limits.free_active_contacts_limit:
organization.is_suspended = True
for project in organization.project.all():
app.send_task(
"update_suspend_project",
args=[str(project.flow_organization), True],
)
organization.save(update_fields=["is_suspended"])
organization.organization_billing.send_email_expired_free_plan(
organization.name,
organization.authorizations.values_list("user__email",
flat=True),
)
return True
def CreateWACChannel(self, request, context):
serializer = CreateWACChannelRequestSerializer(message=request)
if serializer.is_valid(raise_exception=True):
project_uuid = serializer.validated_data.get("project_uuid")
project = Project.objects.get(uuid=project_uuid)
grpc_instance = utils.get_grpc_types().get("flow")
try:
response = grpc_instance.create_wac_channel(
user=serializer.validated_data.get("user"),
flow_organization=str(project.flow_organization),
config=serializer.validated_data.get("config"),
phone_number_id=serializer.validated_data.get(
"phone_number_id"),
)
except grpc.RpcError as error:
if error.code() is grpc.StatusCode.INVALID_ARGUMENT:
self.context.abort(grpc.StatusCode.INVALID_ARGUMENT,
"Bad Request")
raise error
return ChannelCreateResponse(
uuid=response.uuid,
name=response.name,
config=response.config,
address=response.address,
)
def sync_channels_statistics():
flow_instance = utils.get_grpc_types().get("flow")
for project in Project.objects.all():
project.extra_active_integration = len(
list(
flow_instance.list_channel(
project_uuid=str(project.flow_organization))))
project.save(update_fields=["extra_active_integration"])
def create_project(project_name: str, user_email: str, project_timezone: str):
grpc_instance = utils.get_grpc_types().get("flow")
project = grpc_instance.create_project(
project_name=project_name,
user_email=user_email,
project_timezone=project_timezone,
)
return {"id": project.id, "uuid": project.uuid}
def sync_project_statistics():
flow_instance = utils.get_grpc_types().get("flow")
for project in Project.objects.all():
statistic_project_result = flow_instance.get_project_statistic(
project_uuid=str(project.flow_organization), )
if len(statistic_project_result) > 0:
project.flow_count = int(
statistic_project_result.get("active_flows"))
project.save(update_fields=["flow_count"])
def get_billing_total_statistics(project_uuid: str, before: str, after: str):
grpc_instance = utils.get_grpc_types().get("flow")
contact_count = grpc_instance.get_billing_total_statistics(
project_uuid=str(project_uuid),
before=before,
after=after,
)
return contact_count
def retrieve_classifier(classifier_uuid: str):
grpc_instance = utils.get_grpc_types().get("flow")
response = grpc_instance.get_classifier(
classifier_uuid=str(classifier_uuid), )
return dict(
authorization_uuid=response.get("access_token"),
classifier_type=response.get("classifier_type"),
name=response.get("name"),
is_active=response.get("is_active"),
uuid=response.get("uuid"),
)
def ReleaseChannel(self, request, context):
serializer = ReleaseChannelRequestSerializer(message=request)
serializer.is_valid(raise_exception=True)
grpc_instance = utils.get_grpc_types().get("flow")
grpc_instance.release_channel(
channel_uuid=serializer.validated_data.get("channel_uuid"),
user=serializer.validated_data.get("user"),
)
return empty_pb2.Empty()
def sync_project_information():
flow_instance = utils.get_grpc_types().get("flow")
for project in Project.objects.all():
flow_result = flow_instance.get_project_info(
project_uuid=str(project.flow_organization))
if len(flow_result) > 0:
project.name = flow_result.get("name")
project.timezone = str(flow_result.get("timezone"))
project.date_format = str(flow_result.get("date_format"))
project.flow_id = flow_result.get("id")
project.save(
update_fields=["name", "timezone", "date_format", "flow_id"])
def search_project(organization_id: int, project_uuid: str, text: str):
flow_result = (utils.get_grpc_types().get("flow").get_project_flows(
project_uuid=project_uuid,
flow_name=text,
))
inteligence_result = (
IntelligenceRESTClient().get_organization_intelligences(
intelligence_name=text, organization_id=organization_id))
return {
"flow": flow_result,
"inteligence": inteligence_result,
}
def list_channels(project_uuid, channel_type):
grpc_instance = utils.get_grpc_types().get("flow")
response = list(
grpc_instance.list_channel(project_uuid=project_uuid,
channel_type=channel_type))
channels = []
for channel in response:
channels.append({
"uuid": channel.uuid,
"name": channel.name,
"config": channel.config,
"address": channel.address,
})
return channels
def DestroyClassifier(self, request, context):
serializer = DestroyClassifierRequestSerializer(message=request)
if serializer.is_valid(raise_exception=True):
classifier_uuid = serializer.validated_data.get("uuid")
user_email = serializer.validated_data.get("user_email")
grpc_instance = utils.get_grpc_types().get("flow")
grpc_instance.delete_classifier(
classifier_uuid=str(classifier_uuid),
user_email=str(user_email),
)
return empty_pb2.Empty()
def create_channel(user, project_uuid, data, channeltype_code):
grpc_instance = utils.get_grpc_types().get("flow")
try:
response = grpc_instance.create_channel(
user=user,
project_uuid=project_uuid,
data=data,
channeltype_code=channeltype_code)
return dict(uuid=response.uuid,
name=response.name,
config=response.config,
address=response.address)
except grpc.RpcError as error:
raise error
def update_user_permission_project(flow_organization: str, project_uuid: str,
user_email: str, permission: int):
flow_instance = utils.get_grpc_types().get("flow")
integrations_client = IntegrationsRESTClient()
flow_instance.update_user_permission_project(
organization_uuid=flow_organization,
user_email=user_email,
permission=permission,
)
integrations_client.update_user_permission_project(
project_uuid=project_uuid, user_email=user_email, role=permission)
return True
def create_wac_channel(user, flow_organization, config, phone_number_id):
grpc_instance = utils.get_grpc_types().get("flow")
try:
response = grpc_instance.create_wac_channel(
user=user,
flow_organization=str(flow_organization),
config=config,
phone_number_id=phone_number_id,
)
return dict(uuid=response.uuid,
name=response.name,
config=response.config,
address=response.address)
except grpc.RpcError as error:
raise error
def RetrieveClassifier(self, request, context):
serializer = RetrieveClassifierRequestSerializer(message=request)
if serializer.is_valid(raise_exception=True):
classifier_uuid = serializer.validated_data.get("uuid")
grpc_instance = utils.get_grpc_types().get("flow")
response = grpc_instance.get_classifier(
classifier_uuid=str(classifier_uuid), )
return ClassifierResponse(
authorization_uuid=response.get("access_token"),
classifier_type=response.get("classifier_type"),
name=response.get("name"),
is_active=response.get("is_active"),
uuid=response.get("uuid"),
)
def create_classifier(project_uuid: str, user_email: str, classifier_name: str,
access_token):
grpc_instance = utils.get_grpc_types().get("flow")
response = grpc_instance.create_classifier(
project_uuid=project_uuid,
user_email=user_email,
classifier_type="bothub",
classifier_name=classifier_name,
access_token=access_token,
)
return dict(
authorization_uuid=response.access_token,
classifier_type=response.classifier_type,
name=response.name,
is_active=response.is_active,
uuid=response.uuid,
)
def Channel(self, request, context):
grpc_instance = utils.get_grpc_types().get("flow")
channel_type = getattr(request, "channel_type")
for project in Project.objects.all():
response = grpc_instance.list_channel(
project_uuid=str(project.flow_organization),
channel_type=channel_type,
)
for channel in response:
yield ChannelListResponse(
uuid=channel.uuid,
name=channel.name,
config=channel.config,
address=channel.address,
project_uuid=str(project.uuid),
)
def sync_repositories_statistics():
flow_instance = utils.get_grpc_types().get("flow")
ai_client = IntelligenceRESTClient()
for project in Project.objects.all():
classifiers_project = flow_instance.get_classifiers(
project_uuid=str(project.flow_organization),
classifier_type="bothub",
is_active=True,
)
try:
intelligence_count = int(
ai_client.get_count_intelligences_project(
classifiers=classifiers_project, ).get(
"repositories_count"))
except Exception:
intelligence_count = 0
project.intelligence_count = intelligence_count
project.save(update_fields=["inteligence_count"])
def get_contacts_detailed(project_uuid: str, before: str, after: str):
grpc_instance = utils.get_grpc_types().get("flow")
project = Project.objects.get(uuid=project_uuid)
response = []
try:
contacts = grpc_instance.get_active_contacts(
str(project.flow_organization), before, after)
active_contacts_info = []
for contact in contacts:
active_contacts_info.append({
"name": contact.name,
"uuid": contact.uuid
})
response.append({
"project_name": project.name,
"active_contacts": len(active_contacts_info),
"contacts_info": active_contacts_info,
})
return response
except grpc.RpcError as e:
if e.code() is not grpc.StatusCode.NOT_FOUND:
raise e
def Classifier(self, request, context):
serializer = ClassifierRequestSerializer(message=request)
if serializer.is_valid(raise_exception=True):
project_uuid = serializer.validated_data.get("project_uuid")
project = Project.objects.get(uuid=project_uuid)
grpc_instance = utils.get_grpc_types().get("flow")
response = grpc_instance.get_classifiers(
project_uuid=str(project.flow_organization),
classifier_type="bothub",
is_active=True,
)
for i in response:
yield ClassifierResponse(
authorization_uuid=i.get("authorization_uuid"),
classifier_type=i.get("classifier_type"),
name=i.get("name"),
is_active=i.get("is_active"),
uuid=i.get("uuid"),
)
def list_classifier(project_uuid: str):
grpc_instance = utils.get_grpc_types().get("flow")
response = grpc_instance.get_classifiers(
project_uuid=str(project_uuid),
classifier_type="bothub",
is_active=True,
)
classifiers = {"data": []}
for i in response:
classifiers["data"].append({
"authorization_uuid":
i.get("authorization_uuid"),
"classifier_type":
i.get("classifier_type"),
"name":
i.get("name"),
"is_active":
i.get("is_active"),
"uuid":
i.get("uuid"),
})
return classifiers
def CreateClassifier(self, request, context):
serializer = CreateClassifierRequestSerializer(message=request)
if serializer.is_valid(raise_exception=True):
project_uuid = serializer.validated_data.get("project_uuid")
project = Project.objects.get(uuid=project_uuid)
grpc_instance = utils.get_grpc_types().get("flow")
response = grpc_instance.create_classifier(
project_uuid=str(project.flow_organization),
user_email=serializer.validated_data.get("user"),
classifier_type="bothub",
classifier_name=serializer.validated_data.get("name"),
access_token=serializer.validated_data.get("access_token"),
)
return ClassifierResponse(
authorization_uuid=response.get("access_token"),
classifier_type=response.get("classifier_type"),
name=response.get("name"),
is_active=response.get("is_active"),
uuid=response.get("uuid"),
)
def delete_user_permission_project(project_uuid: str, user_email: str,
permission: int):
utils.get_grpc_types().get("flow").delete_user_permission_project(
project_uuid=project_uuid,
user_email=user_email,
permission=permission)
