def close_ticket(prescription):
if not isinstance(prescription, MedicalPrescription):
return False
mticket = ZendeskTicket.objects.filter(prescription=prescription).first()
zenpy_client = Zenpy(**settings.ZENDESK)
if not mticket:
return False
ticket = zenpy_client.tickets(id=mticket.external_id)
ticket.status = 'solved'
if prescription.status in domain_models.MedicalPrescription.STATUS_CHOICES:
new_cf = []
for cf in ticket.custom_fields:
if cf.get('id', None) == 114103846891:
new_cf.append({
'id': 114103846891,
'value': prescription.status.lower()
})
new_cf.append(cf)
ticket.custom_fields = new_cf
ticket_audit = zenpy_client.tickets.update(ticket)
if ticket_audit:
return True
return False
def __init__(self, user, token, NoOfdays):
self.creds = {'email': user, 'token': token, 'subdomain': 'qubole'}
self.client = Zenpy(**self.creds)
self.startTime = datetime.datetime.now() - datetime.timedelta(
days=NoOfdays)
self.result_generator = self.client.tickets.incremental(
start_time=self.startTime)
def _get_client():
global zenpy_client
# Zenpy will let the connection timeout after 5s and will retry 3 times
if not zenpy_client:
zenpy_client = Zenpy(timeout=5, **ZENPY_CREDENTIALS)
return zenpy_client
def main():
parsed_args = singer.utils.parse_args(REQUIRED_CONFIG_KEYS)
creds = {"subdomain": parsed_args.config['subdomain']}
try:
oauth_args = singer.utils.parse_args(OAUTH_CONFIG_KEYS)
creds.update({
"oauth_token": oauth_args.config['access_token'],
})
except:
LOGGER.debug("Cannot find oauth configuration.")
try:
api_args = singer.utils.parse_args(API_CONFIG_KEYS)
creds.update({
"email": api_args.config['email'],
"token": api_args.config['api_token']
})
except:
LOGGER.debug("Cannot find api token configuration.")
client = Zenpy(**creds)
if parsed_args.discover:
do_discover(client)
elif parsed_args.catalog:
state = parsed_args.state
do_sync(client, parsed_args.catalog, state,
parsed_args.config['start_date'])
def create_support_request(user, email, message, attachments=()):
client = Zenpy(
subdomain=settings.ZENDESK_SUBDOMAIN,
email=settings.ZENDESK_EMAIL,
token=settings.ZENDESK_TOKEN,
)
ticket_audit = client.tickets.create(
Ticket(
subject='Data Workspace Support Request',
description=message,
requester=User(email=email, name=user.get_full_name()),
custom_fields=[
CustomField(
id=zendesk_service_field_id, value=zendesk_service_field_value
)
],
)
)
if attachments:
uploads = [client.attachments.upload(x) for x in attachments]
ticket_audit.ticket.comment = Comment(
body='Additional attachments', uploads=[x.token for x in uploads]
)
client.tickets.update(ticket_audit.ticket)
return ticket_audit.ticket.id
def __init__(self, *args, **kwargs):
creds = {
"email": settings.ZENDESK_EMAIL,
"token": settings.ZENDESK_TOKEN,
"subdomain": settings.ZENDESK_SUBDOMAIN,
}
self.client = Zenpy(**creds)
def main():
parsed_args = singer.utils.parse_args(REQUIRED_CONFIG_KEYS)
# OAuth has precedence
creds = oauth_auth(parsed_args) or api_token_auth(parsed_args)
session = get_session(parsed_args.config)
# Pass some config options into the client
rate_limit_settings = {}
for key in ('proactive_ratelimit', 'proactive_ratelimit_request_interval',
'ratelimit_budget'):
if key in parsed_args.config:
rate_limit_settings[key] = parsed_args.config.pop(key)
LOGGER.info('zenpy rate limit settings = %r', rate_limit_settings)
client = Zenpy(session=session, **rate_limit_settings, **creds)
if not client:
LOGGER.error("""No suitable authentication keys provided.""")
if parsed_args.discover:
do_discover(client)
elif parsed_args.catalog:
state = parsed_args.state
start_date = parsed_args.config['start_date']
lookback_minutes = parsed_args.config.get('lookback_minutes')
do_sync(client, parsed_args.catalog, state, start_date,
lookback_minutes)
def create_ticket(title, description, impact, history, name, email):
global ticket_number
zendesk_client = Zenpy(**creds)
# Create a new ticket
ticket_audit = zendesk_client.tickets.create(
Ticket(
subject=title,
requester=User(name=name, email=email),
comment=Comment(
html_body=
'<h3>Request Details</h3><pre><code>Title: {}<br>Request: {}<br>'
'Impact: {}<br>History: {}</code></pre><h3>Submitter Details</h3><pre><code>'
'Name: {}<br>Email: {}</code></pre>'.format(
title, description, impact, history, name, email)),
type="problem",
priority="normal",
requester_id="366101959011",
submitter_id="366101959011",
ticket_form_id="360000072631",
group_id="360000964291",
collaborator_ids=["443254580", "656182144"],
follower_ids=["443254580", "656182144"],
custom_fields=[
CustomField(id=360005680151,
value='request_to_update_existing_process')
]))
ticket_number = ticket_audit.ticket.id
def index():
try: # We use try method to keep running if there is no API available.
# Default
zenpy_client = Zenpy(**creds)
ticket_generator = zenpy_client.tickets()
return render_template('index.html', tickets=ticket_generator)
except:
print("Sorry, API isn't currently available")
def send_to_zendesk(request_email, subject, message, user=None):
ticket = create_zendesk_ticket(request_email, subject, message, user)
zenpy = Zenpy(
email=settings.ZENDESK_EMAIL,
token=settings.ZENDESK_TOKEN,
subdomain='freesound'
)
zenpy.tickets.create(ticket)
def delete_all_tickets():
zenpy_client = Zenpy(**settings.ZENDESK)
for ticket in zenpy_client.search(status="new"):
zenpy_client.tickets.delete(ticket)
for ticket in zenpy_client.search(status="open"):
zenpy_client.tickets.delete(ticket)
def __init__(self, **kwargs):
"""Initialize Zendesk API client."""
creds = {
"email": settings.ZENDESK_USER_EMAIL,
"token": settings.ZENDESK_API_TOKEN,
"subdomain": settings.ZENDESK_SUBDOMAIN,
}
self.client = Zenpy(**creds)
def __init__(self):
self._creds = {
'email': os.environ.get('ZENDESK_USER', None),
'token': os.environ.get('ZENDESK_TOKEN', None),
'subdomain': "pagarme"
}
self._zenpy_client = Zenpy(**self._creds)
self._sl = SlackConnection.SlackConnection()
self._mc = MongoConnection.MongoConnection()
def send_to_zendesk(request_email, subject, message, user=None):
ticket = create_zendesk_ticket(request_email, subject, message, user)
zenpy = Zenpy(email=settings.ZENDESK_EMAIL,
token=settings.ZENDESK_TOKEN,
subdomain='freesound')
try:
zenpy.tickets.create(ticket)
except (ZendeskAPIException, HTTPError, ZenpyException) as e:
web_logger.info('Error creating Zendesk ticket: {}'.format(str(e)))
def get_description(ticket_id):
global zenpy_client
try:
zenpy_client = Zenpy(**credentials)
ticket = zenpy_client.tickets(id=ticket_id)
return ticket.description
except Exception as e:
logger.exception("get_description {}".format(e))
raise
def zenpyz(oauth_token):
creds = {"subdomain": subdomain, "oauth_token": oauth_token}
# Import the Zenpy Class
from zenpy import Zenpy
zenpy_client = Zenpy(**creds)
for comment in zenpy_client.tickets.comments(ticket_id=98):
print comment.body
def etl():
s3 = boto3.client(
's3',
aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
region_name=os.getenv("AWS_DEFAULT_REGION"),
)
zenpy = Zenpy(
email=os.getenv("ZENDESK_EMAIL"),
token=os.getenv("ZENDESK_TOKEN"),
subdomain=os.getenv("OUR_SUBDOMAIN"),
)
dsn_string = os.getenv("REDSHIFT_CONN_STRING")
# Process nonform tickets
conn = psycopg2.connect(dsn_string)
conn.set_session(autocommit=True)
nonform_query = "SELECT MAX(created_at) FROM zendesk.tickets WHERE LENGTH(ticket_form)=0"
start_date, end_date = find_dates(conn, query=nonform_query)
filename = time.strftime("%d_%m_%Y") + '_zendesk_tickets.json'
extract_tickets(zenpy, start_date, end_date, filename)
stage_and_load_tickets(conn, s3, filename)
delete_duplicates(conn)
conn.close()
# Process form tickets
form_dsn = "host='hostname' dbname='public' user='******' password='******' port='5439'"
conn = psycopg2.connect(dsn_string)
conn.set_session(autocommit=True)
form_query = "SELECT MAX(created_at) FROM zendesk.tickets WHERE LENGTH(ticket_form)>0"
start_date, end_date = find_dates(conn, query=form_query)
ticket_forms = [
'Pre sale product enquiry',
'Pre sale delivery enquiry',
'Pre sale invoice enquiry',
'Pre sale service enquiry',
'Pre despatch order enquiry',
'Post despatch delivery enquiry',
'Post despatch returns enquiry',
'Post despatch item damaged',
'Technical enquiry',
'Post despatch general enquiry',
]
for form in tqdm(ticket_forms, leave=True):
filename = time.strftime("%d_%m_%Y") + '_zendesk_tickets_' + str(
form) + '.json'
extract_tickets(zenpy, start_date, end_date, filename, form=form)
stage_and_load_tickets(conn, s3, filename)
delete_duplicates(conn)
conn.close()
def update_ticket(ticket_id, message):
global zenpy_client
comment = "```\n{}\n```".format(message)
try:
zenpy_client = Zenpy(**credentials)
ticket = zenpy_client.tickets(id=ticket_id)
ticket.comment = Comment(body=comment, public=False)
zenpy_client.tickets.update(ticket)
except Exception as e:
logger.exception("update_ticket {}".format(e))
raise
def get_unclosed_tickets(email: str, token: str,
subdomain: str) -> Iterable[Ticket]:
zenpy = Zenpy(subdomain, email, token)
ticket: ZendeskTicket
for ticket in zenpy.tickets():
requester: ZendeskUser = ticket.requester
waiting_on = None
staled_at = None
yield Ticket(ticket.id, ticket.subject, requester.email,
requester.email, ticket.status, waiting_on, staled_at,
ticket.created_at)
def zdviewtest(view_title):
zd_client = Zenpy(**creds)
view = next(iter(zd_client.views.search(query=view_title) or []), None)
print(view.title)
for ticket in zd_client.views.tickets(view):
metrics = zd_client.tickets.metrics(ticket.id)
dd, hh, mm = days_hours_minutes(
parse(metrics.status_updated_at) - parse(metrics.created_at))
print(u"{0};{1};{2};{3};{4};{5};{6};{7}".format(
ticket.id, ticket.subject, ticket.status, metrics.created_at,
metrics.status_updated_at, dd, hh, mm))
def create_zendesk_ticket(self):
zenpy_client = Zenpy(
subdomain=settings.ZENDESK_SUBDOMAIN,
email=settings.ZENDESK_EMAIL,
token=settings.ZENDESK_TOKEN,
)
attachments = [
value for field, value in self.cleaned_data.items()
if field.startswith('attachment') and value
]
if attachments:
uploads = []
for attachment in attachments:
upload_instance = zenpy_client.attachments.upload(
attachment.temporary_file_path())
uploads.append(upload_instance.token)
else:
uploads = None
service = SERVICE_FIELD_MAPPING[self.cleaned_data['platform']]
custom_fields = [
CustomField(id=30041969, value=service), # service
CustomField(id=360000180437,
value=self.cleaned_data['department']), # directorate
CustomField(id=45522485,
value=self.cleaned_data['email']), # email
CustomField(id=360000188178,
value=self.cleaned_data['telephone']), # Phone number
CustomField(
id=360000182638,
value=self.cleaned_data['request_type']), # Content request
CustomField(id=360000180477,
value=self.cleaned_data['publication_date_explanation']
), # reason
CustomField(id=360000180457,
value=str(
self.cleaned_data['publication_date'])) # due date
]
ticket = zenpy_client.tickets.create(
Ticket(subject=self.cleaned_data['title_of_request'],
custom_fields=custom_fields,
tags=['content_delivery', self.cleaned_data['platform']],
comment=Comment(html_body=self.formatted_text(),
uploads=uploads),
requester=User(name=self.cleaned_data['name'],
email=self.cleaned_data['email']))).ticket
return ticket.id
def validate_zendesk_credentials(subdomain: str, user_name: str,
api_token: str):
from zenpy import Zenpy
from zenpy.lib.exception import APIException
try:
zendesk_client = Zenpy(subdomain=subdomain,
email=user_name,
token=api_token)
list(zendesk_client.search(assignee='test'))
except APIException as e:
raise ActionFailure(e)
def get_client(config):
"""Given a `config`, create a Zenpy API client."""
zenpy_args = dict([
(zenpy_key, getattr(config, config_key, None))
for zenpy_key, config_key in [(
'email', 'email'), ('password',
'password'), ('subdomain', 'subdomain')]
])
try:
zenpy_client = Zenpy(**zenpy_args)
except zenpy.lib.exception.ZenpyException as exc:
if getattr(config, 'unpickle_tickets', None):
zenpy_args['password'] = zenpy_args['password'] or 'dummy_pass'
zenpy_args['subdomain'] = zenpy_args['subdomain'] \
or 'dummy_subdomain'
zenpy_args['email'] = zenpy_args['email'] or 'dummy_email'
zenpy_client = Zenpy(**zenpy_args)
else:
raise ZTVConfigException(str(exc))
return handle_pickling(config, zenpy_client)
def __init__(self, config):
super(ZendeskAction, self).__init__(config=config)
self.email = self.config['email']
self.token = self.config['api_token']
self.subdomain = self.config['subdomain']
self.credentials = {
'email': self.email,
'token': self.token,
'subdomain': self.subdomain
}
self.api = Zenpy(**self.credentials)
def oauth_auth(args):
if not set(OAUTH_CONFIG_KEYS).issubset(args.config.keys()):
LOGGER.debug("OAuth authentication unavailable.")
return None
creds = {
"subdomain": args.config['subdomain'],
"oauth_token": args.config['access_token'],
}
client = Zenpy(**creds)
LOGGER.info("Using OAuth authentication.")
return client
def test_get_tickets_return():
"""
Test get_tickets() using pytest framework
:return: void
"""
try:
zenpy_client = Zenpy(**creds)
tickets = get_tickets(zenpy_client)
except APIException:
print("Error connecting to API")
sys.exit(1)
# Verify list was returned
assert tickets is not None
def import_tickets(tickets):
creds = {
'email': os.environ['DATABOT_ZD_EMAIL'],
'token': os.environ['DATABOT_ZD_TOKEN'],
'subdomain': os.environ['DATABOT_ZD_SUBDOMAIN']
}
zenpy_client = Zenpy(**creds)
# Create a new ticket
for ticket in tickets:
print ticket
ticket = Ticket(**ticket)
zenpy_client.ticket_import.create(ticket)
def test_get_tickets_type():
"""
Test get_tickets() using pytest framework
:return: void
"""
try:
zenpy_client = Zenpy(**creds)
tickets = get_tickets(zenpy_client)
except APIException:
print("Error connecting to API")
sys.exit(1)
# Verify type
if len(tickets) > 0:
assert isinstance(tickets[0], Ticket)
def api_token_auth(args):
if not set(API_TOKEN_CONFIG_KEYS).issubset(args.config.keys()):
LOGGER.debug("API Token authentication unavailable.")
return None
creds = {
"subdomain": args.config['subdomain'],
"email": args.config['email'],
"token": args.config['api_token']
}
client = Zenpy(**creds)
LOGGER.info("Using API Token authentication.")
return client
def __init__(self, **data: Any):
super().__init__(**data)
if self.cred_info is None:
self.cred_info = ZendeskCredInfo()
self._client = Zenpy(
domain=self.domain,
subdomain=self.subdomain,
email=self.cred_info.email,
password=self.cred_info.password.get_secret_value(),
oauth_token=self.cred_info.oauth_token.get_secret_value(),
token=self.cred_info.token.get_secret_value(),
)
