From 65dd73efb396b8b79cf9a27860b1afcae85f3ad6 Mon Sep 17 00:00:00 2001 From: Claudia Anderson Date: Wed, 19 Feb 2025 15:16:32 +0000 Subject: [PATCH] Updated SDK version Updated imports for the latest sdk version Added grpcConnection pooling Added resend welcome email method --- .vscode/settings.json | 6 ++ coupons/create-campaign.py | 31 +++++--- coupons/create-coupon.py | 43 +++++++---- coupons/create-offer.py | 108 ++++++++++++++++------------ coupons/list-coupons.py | 43 ++++++++--- coupons/redeem-coupon.py | 31 +++++--- coupons/update-coupon.py | 44 ++++++++---- coupons/void-coupon.py | 36 ++++++---- flights/create-airport.py | 38 ++++++---- flights/create-boarding-pass.py | 55 ++++++++------ flights/create-carrier.py | 34 ++++++--- flights/create-flight-designator.py | 66 ++++++++++------- flights/create-flight.py | 64 ++++++++++------- flights/delete-airport.py | 28 +++++--- flights/delete-carrier.py | 28 +++++--- flights/delete-flight-designator.py | 32 ++++++--- flights/delete-flight.py | 19 +++-- membership/burn-points.py | 44 ++++++++---- membership/check-in-member.py | 43 +++++++---- membership/check-out-member.py | 45 ++++++++---- membership/create-program.py | 45 ++++++++---- membership/create-tier.py | 72 ++++++++++++------- membership/delete-member.py | 38 ++++++---- membership/earn-points.py | 43 +++++++---- membership/enrol-member.py | 59 +++++++++------ membership/update-member.py | 51 ++++++++----- shared/grpcConnection.py | 44 ++++++++++++ shared/grpcConnectionPooling.py | 72 +++++++++++++++++++ shared/resend-welcome-email.py | 40 +++++++++++ 29 files changed, 906 insertions(+), 396 deletions(-) create mode 100644 .vscode/settings.json create mode 100644 shared/grpcConnection.py create mode 100644 shared/grpcConnectionPooling.py create mode 100644 shared/resend-welcome-email.py diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..9ee86e7 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,6 @@ +{ + "[python]": { + "editor.defaultFormatter": "ms-python.autopep8" + }, + "python.formatting.provider": "none" +} \ No newline at end of file diff --git a/coupons/create-campaign.py b/coupons/create-campaign.py index b1ff59e..66a1fc4 100644 --- a/coupons/create-campaign.py +++ b/coupons/create-campaign.py @@ -1,24 +1,37 @@ import grpc -import io.single_use_coupons.campaign_pb2 as campaign_pb2 -import io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.single_use_coupons.campaign_pb2 as campaign_pb2 +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc def create_campaign(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub couponsStub = a_rpc_pb2_grpc.SingleUseCouponsStub(channel) # Create campaign campaign = campaign_pb2.CouponCampaign() - campaign.Name = "Quickstart Campaign" - campaign.Status = [1, 4] + campaign.name = "Quickstart Campaign" + campaign.status.append("PROJECT_ACTIVE_FOR_OBJECT_CREATION") + campaign.status.append("PROJECT_DRAFT") response = couponsStub.createCouponCampaign(campaign) print(response) diff --git a/coupons/create-coupon.py b/coupons/create-coupon.py index cfde837..7dd0c7b 100644 --- a/coupons/create-coupon.py +++ b/coupons/create-coupon.py @@ -1,32 +1,45 @@ import grpc -import io.single_use_coupons.coupon_pb2 as coupon_pb2 -import io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc -import io.common.personal_pb2 as personal_pb2 +import passkit_io.single_use_coupons.coupon_pb2 as coupon_pb2 +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc +from passkit_io.common.personal_pb2 import Person def create_coupon(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub couponsStub = a_rpc_pb2_grpc.SingleUseCouponsStub(channel) # Create coupon coupon = coupon_pb2.Coupon() - coupon.OfferId = "" # Get offerId from createOffer call or dashboard - coupon.CampaignId = "" # Get campaignId from createCampaign call or dashboard - coupon.Sku = "" + coupon.offerId = "" # Get offerId from createOffer call or dashboard + coupon.campaignId = "" # Get campaignId from createCampaign call or dashboard - person = personal_pb2.Person() - person.DisplayName = "Loyal Larry" - person.EmailAddress = "" + person = Person() + person.displayName = "Percy PassKit" + person.surname = "PassKit" + person.forename = "Percy" + person.emailAddress = "" - coupon.Person = person + coupon.person.CopyFrom(person) response = couponsStub.createCoupon(coupon) print(response) diff --git a/coupons/create-offer.py b/coupons/create-offer.py index 1ea1d5e..356318f 100644 --- a/coupons/create-offer.py +++ b/coupons/create-offer.py @@ -1,20 +1,32 @@ import grpc -import io.single_use_coupons.offer_pb2 as offer_pb2 -import io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc -import io.core.a_rpc_templates_pb2_grpc as a_rpc_templates_pb2_grpc -import io.common.template_pb2 as template_pb2 +import passkit_io.single_use_coupons.offer_pb2 as offer_pb2 +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.core.a_rpc_templates_pb2_grpc as a_rpc_templates_pb2_grpc +import passkit_io.common.template_pb2 as template_pb2 import google.protobuf.timestamp_pb2 as timestamp_pb2 import datetime def create_offer(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub couponsStub = a_rpc_pb2_grpc.SingleUseCouponsStub(channel) @@ -24,50 +36,56 @@ def create_offer(): # Create template templateRequest = template_pb2.DefaultTemplateRequest() - templateRequest.Protocol = "SINGLE_USE_COUPON" - templateRequest.Revision = 1 + templateRequest.protocol = "SINGLE_USE_COUPON" + templateRequest.revision = 1 template = templatesStub.getDefaultTemplate(templateRequest) - template.Name = "Quickstart Base Offer" - template.Description = "Quickstart Base Offer Pass" - template.Timezone = "Europe/London" + template.name = "Quickstart Base Offer" + template.description = "Quickstart Base Offer Pass" + template.timezone = "Europe/London" - templateId = templatesStub.createTemplate(template) + try: + response = templatesStub.createTemplate(template) + print("Template " + response.id + " successfully created") + except grpc.RpcError as e: + print("Failed to create template", e.details()) # Create offer offer = offer_pb2.CouponOffer() - offer.Id = "Base Offer" - offer.OfferTitle = "Base Offer Title" - offer.OfferShortTitle = "Base Offer" - offer.OfferDetails = "Base Offer Details" - offer.OfferFinePrint = "Base Offer fine print" - offer.BeforeRedeemPassTemplateId(templateId.Id) - - issueStartDate = datetime.datetime.strptime( - "10/9/2023", "%d/%m/%Y").timestamp() - issueEndDate = datetime.datetime.strptime( - "10/11/2023", "%d/%m/%Y").timestamp() - redemptionStartDate = datetime.datetime.strptime( - "10/9/2023", "%d/%m/%Y").timestamp() - redemptionEndDate = datetime.datetime.strptime( - "10/11/2023", "%d/%m/%Y").timestamp() - + offer.id = "Base Offer" + offer.offerTitle = "Base Offer Title" + offer.offerShortTitle = "Base Offer" + offer.offerDetails = "Base Offer Details" + offer.offerFinePrint = "Base Offer fine print" + offer.beforeRedeemPassTemplateId = response.id + + # Get current UTC time as timezone-aware datetime + issueStartDate = datetime.datetime.now(datetime.timezone.utc) + issueEndDate = datetime.datetime.now(datetime.timezone.utc) + redemptionStartDate = datetime.datetime.now(datetime.timezone.utc) + redemptionEndDate = datetime.datetime.now(datetime.timezone.utc) + + # Convert the datetime objects to Timestamp redemptionSettings = offer_pb2.RedemptionSettings() - redemptionSettings.RedemptionStartDate = timestamp_pb2.Timestamp( - redemptionStartDate) - redemptionSettings.RedemptionEndDate = timestamp_pb2.Timestamp( - redemptionEndDate) - - couponExpirySettings = offer_pb2.CouponExpirySettings - couponExpirySettings.CouponExpiryType = "AUTO_EXPIRE_REDEMPTION_END_DATE" - - offer.IssueStartDate = timestamp_pb2.Timestamp(issueStartDate) - offer.IssueEndDate = timestamp_pb2.Timestamp(issueEndDate) - offer.RedemptionSettings = redemptionSettings - offer.CouponExpirySettings = couponExpirySettings - offer.CampaignId = "" # Get from campaignId from createCampaign call or dashboard - offer.IanaTimezone = "Europe/London" + redemptionSettings.redemptionStartDate = redemptionStartDate + + redemptionSettings.redemptionEndDate = redemptionEndDate + + couponExpirySettings = offer_pb2.CouponExpirySettings() + couponExpirySettings.couponExpiryType = "AUTO_EXPIRE_REDEMPTION_END_DATE" + + offer.issueStartDate = issueStartDate + + offer.issueEndDate = issueEndDate + + # Assign settings + offer.redemptionSettings.CopyFrom(redemptionSettings) + offer.couponExpirySettings.CopyFrom(couponExpirySettings) + offer.campaignId = "" # Get from campaignId from createCampaign call or dashboard + offer.ianaTimezone = "Europe/London" + + # Create coupon offer response = couponsStub.createCouponOffer(offer) print(response) diff --git a/coupons/list-coupons.py b/coupons/list-coupons.py index 98e4da5..e2960bb 100644 --- a/coupons/list-coupons.py +++ b/coupons/list-coupons.py @@ -1,26 +1,47 @@ import grpc -import io.single_use_coupons.coupon_pb2 as coupon_pb2 -import io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.single_use_coupons.coupon_pb2 as coupon_pb2 +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc def list_coupons(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub couponsStub = a_rpc_pb2_grpc.SingleUseCouponsStub(channel) # List coupons by campaignId listCouponRequest = coupon_pb2.ListRequest() - listCouponRequest.CouponCampaignId = "" # Campaign Id of coupons to list - - response = couponsStub.listCouponsByCouponCampaign(listCouponRequest) - print(response) + listCouponRequest.couponCampaignId = "0S5FnxW9i2e0fBa8chRhBw" # Campaign Id of coupons to list + + try: + couponsList = couponsStub.listCouponsByCouponCampaign(listCouponRequest, timeout=30) + for data in couponsList: + # This will print each member data received from the stream + print("Received:", data) + + print("Stream ended successfully.") + except grpc.RpcError as e: + print(f"gRPC Error: {e.code()} - {e.details()}") + except Exception as e: + print(f"Error: {e}") list_coupons() diff --git a/coupons/redeem-coupon.py b/coupons/redeem-coupon.py index b491faa..0e1948a 100644 --- a/coupons/redeem-coupon.py +++ b/coupons/redeem-coupon.py @@ -1,25 +1,36 @@ import grpc -import io.single_use_coupons.coupon_pb2 as coupon_pb2 -import io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.single_use_coupons.coupon_pb2 as coupon_pb2 +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc def redeem_coupon(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub couponsStub = a_rpc_pb2_grpc.SingleUseCouponsStub(channel) # Redeem coupon coupon = coupon_pb2.Coupon() - coupon.Id = "" # Id of coupon to void - coupon.CampaignId = "" # Get campaignId from createCampaign call or dashboard - coupon.Status = 1 + coupon.id = "" # Id of coupon to void + coupon.campaignId = "" # Get campaignId from createCampaign call or dashboard response = couponsStub.redeemCoupon(coupon) print(response) diff --git a/coupons/update-coupon.py b/coupons/update-coupon.py index ee75cea..6f83807 100644 --- a/coupons/update-coupon.py +++ b/coupons/update-coupon.py @@ -1,32 +1,46 @@ import grpc -import io.single_use_coupons.coupon_pb2 as coupon_pb2 -import io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc -import io.common.personal_pb2 as personal_pb2 +import passkit_io.single_use_coupons.coupon_pb2 as coupon_pb2 +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc +from passkit_io.common.personal_pb2 import Person def update_coupon(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub couponsStub = a_rpc_pb2_grpc.SingleUseCouponsStub(channel) # Update coupon coupon = coupon_pb2.Coupon() - coupon.Id = "" # Id of coupon to update - coupon.OfferId = "" # Get offerId from createOffer call or dashboard - coupon.CampaignId = "" # Get campaignId from createCampaign call or dashboard + coupon.id = "" + coupon.offerId = "" # Get offerId from createOffer call or dashboard + coupon.campaignId = "" # Get campaignId from createCampaign call or dashboard - person = personal_pb2.Person() - person.DisplayName = "Loyal Larry" - person.EmailAddress = "" + person = Person() + person.displayName = "Percy PassKit" + person.surname = "PassKit" + person.forename = "Perc" + person.emailAddress = "" - coupon.Person = person + coupon.person.CopyFrom(person) response = couponsStub.updateCoupon(coupon) print(response) diff --git a/coupons/void-coupon.py b/coupons/void-coupon.py index 2964cc8..85076a4 100644 --- a/coupons/void-coupon.py +++ b/coupons/void-coupon.py @@ -1,28 +1,40 @@ import grpc -import io.single_use_coupons.coupon_pb2 as coupon_pb2 -import io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.single_use_coupons.coupon_pb2 as coupon_pb2 +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as a_rpc_pb2_grpc def void_coupon(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub couponsStub = a_rpc_pb2_grpc.SingleUseCouponsStub(channel) # Void coupon coupon = coupon_pb2.Coupon() - coupon.Id = "" # Id of coupon to void - coupon.OfferId = "" # Get offerId from createOffer call or dashboard - coupon.CampaignId = "" # Get campaignId from createCampaign call or dashboard + coupon.id = "2saS6qfTbuMpMZhHW71Sgz" # Id of coupon to void + coupon.offerId = "6Ju8CP1y05fBz6hwAUhw2Y" # Get offerId from createOffer call or dashboard + coupon.campaignId = "0S5FnxW9i2e0fBa8chRhBw" # Get campaignId from createCampaign call or dashboard - response = couponsStub.update(coupon) - print(response) + response = couponsStub.voidCoupon(coupon) + print("Coupon Voided") void_coupon() diff --git a/flights/create-airport.py b/flights/create-airport.py index 04daf27..d101282 100644 --- a/flights/create-airport.py +++ b/flights/create-airport.py @@ -1,28 +1,40 @@ import grpc -import io.flights.airport_pb2 as airport_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.flights.airport_pb2 as airport_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc def create_airport(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub flightsStub = a_rpc_pb2_grpc.FlightsStub(channel) # Create airport airport = airport_pb2.Port() - airport.AirportName = "ABC Airport" - airport.CityName = "London" - airport.IataAirportCode = "" # Your airport IATA code - airport.IcaoAirportCode = "" # Your airport ICAO code - airport.CountryCode = "IE" - airport.Timezone("Europe/London") + airport.airportName = "ABC Airport" + airport.cityName = "London" + airport.iataAirportCode = "" # Your airport IATA code + airport.icaoAirportCode = "" # Your airport ICAO code + airport.countryCode = "IE" + airport.timezone("Europe/London") response = flightsStub.createPort(airport) print(response) diff --git a/flights/create-boarding-pass.py b/flights/create-boarding-pass.py index b77321f..51e7046 100644 --- a/flights/create-boarding-pass.py +++ b/flights/create-boarding-pass.py @@ -1,40 +1,51 @@ import grpc -import io.flights.boarding_pass_pb2 as boarding_pass_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc -import io.flights.passenger_pb2 as passenger_pb2 +import passkit_io.flights.boarding_pass_pb2 as boarding_pass_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.flights.passenger_pb2 as passenger_pb2 import datetime def create_boarding_pass(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub flightsStub = a_rpc_pb2_grpc.FlightsStub(channel) # Create boarding pass boardingPass = boarding_pass_pb2.BoardingPassRecord() - boardingPass.CarrierCode = "" - boardingPass.BoardingPoint = "ATH" - boardingPass.DeplaningPoint = "LHR" - boardingPass.OperatingCarrierPNR = "" - boardingPass.FlightNumber = "1234" - boardingPass.SequenceNumber = "1" - - departureDate = datetime.datetime.strptime( - "10/9/2023", "%d/%m/%Y").timestamp() + boardingPass.carrierCode = "" + boardingPass.boardingPoint = "ATH" + boardingPass.deplaningPoint = "LHR" + boardingPass.operatingCarrierPNR = "" + boardingPass.flightNumber = "1234" + boardingPass.sequenceNumber = "1" + + departureDate = datetime.datetime.now(datetime.timezone.utc) passenger = passenger_pb2.Passenger - passenger.Forename = "Larry" - passenger.Surname = "Loyalty" - passenger.EmailAddress = "" + passenger.forename = "Larry" + passenger.surname = "Loyalty" + passenger.emailAddress = "" - boardingPass.Passenger = passenger - boardingPass.DepartureDate = departureDate + boardingPass.passenger.CopyFrom(passenger) + boardingPass.departureDate = departureDate response = flightsStub.createBoardingPass(boardingPass) print(response) diff --git a/flights/create-carrier.py b/flights/create-carrier.py index 18b5e30..f07cb71 100644 --- a/flights/create-carrier.py +++ b/flights/create-carrier.py @@ -1,26 +1,38 @@ import grpc -import io.flights.carrier_pb2 as carrier_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.flights.carrier_pb2 as carrier_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc def create_carrier(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub flightsStub = a_rpc_pb2_grpc.FlightsStub(channel) # Create carrier carrier = carrier_pb2.Carrier() - carrier.AirlineName = "ABC Airline" - carrier.IataCarrierCode = "" # Your IATA carrier code - carrier.IcaoCarrierCode = "" # Your ICAO carrier code - carrier.PassTypeIdentifier = "" # Insert your apple certificate id here + carrier.airlineName = "ABC Airline" + carrier.iataCarrierCode = "" # Your IATA carrier code + carrier.icaoCarrierCode = "" # Your ICAO carrier code + carrier.passTypeIdentifier = "" # Insert your apple certificate id here response = flightsStub.createCarrier(carrier) print(response) diff --git a/flights/create-flight-designator.py b/flights/create-flight-designator.py index b08c750..89997e1 100644 --- a/flights/create-flight-designator.py +++ b/flights/create-flight-designator.py @@ -1,30 +1,42 @@ import grpc -import io.flights.flight_designator_pb2 as flight_designator_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.flights.flight_designator_pb2 as flight_designator_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc import datetime def create_flight_designator(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub flightsStub = a_rpc_pb2_grpc.FlightsStub(channel) # Create flight designator flightDesignator = flight_designator_pb2.FlightDesignator() - flightDesignator.CarrierCode = "" - flightDesignator.FlightNumber = "1234" - flightDesignator.Revision = 0 - flightDesignator.Schedule("ADP") - flightDesignator.PassTemplateId = "" # Created when creating flight - flightDesignator.Origin = "YYY" - flightDesignator.Origin = "ADP" + flightDesignator.carrierCode = "" + flightDesignator.flightNumber = "1234" + flightDesignator.revision = 0 + flightDesignator.schedule("ADP") + flightDesignator.passTemplateId = "" # Created when creating flight + flightDesignator.origin = "YYY" + flightDesignator.origin = "ADP" boardingTime = datetime.time(13, 0, 0) scheduledDeparture = datetime.time(14, 0, 0) @@ -32,21 +44,21 @@ def create_flight_designator(): gateTime = datetime.time(13, 30, 0) flightTimes = flight_designator_pb2.FlightTimes() - flightTimes.BoardingTime = boardingTime - flightTimes.ScheduledDepartureTime = scheduledDeparture - flightTimes.ScheduledArrivalTime = scheduledArrival - flightTimes.GateClosingTime = gateTime + flightTimes.boardingTime = boardingTime + flightTimes.scheduledDepartureTime = scheduledDeparture + flightTimes.scheduledArrivalTime = scheduledArrival + flightTimes.gateClosingTime = gateTime schedule = flight_designator_pb2.FlightsSchedule() - schedule.Monday = flightTimes - schedule.Tuesday = flightTimes - schedule.Wednesday = flightTimes - schedule.Thursday = flightTimes - schedule.Friday = flightTimes - schedule.Saturday = flightTimes - schedule.Sunday = flightTimes - - flightDesignator.Schedule = schedule + schedule.monday = flightTimes + schedule.tuesday = flightTimes + schedule.wednesday = flightTimes + schedule.thursday = flightTimes + schedule.friday = flightTimes + schedule.saturday = flightTimes + schedule.sunday = flightTimes + + flightDesignator.Schedule.CopyFrom(schedule) response = flightsStub.createFlightDesignator(flightDesignator) print(response) diff --git a/flights/create-flight.py b/flights/create-flight.py index 243d597..cc815e6 100644 --- a/flights/create-flight.py +++ b/flights/create-flight.py @@ -1,20 +1,32 @@ import grpc -import io.flights.flight_pb2 as flight_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc -import io.core.a_rpc_templates_pb2_grpc as a_rpc_templates_pb2_grpc -import io.common.template_pb2 as template_pb2 +import passkit_io.flights.flight_pb2 as flight_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.core.a_rpc_templates_pb2_grpc as a_rpc_templates_pb2_grpc +import passkit_io.common.template_pb2 as template_pb2 import google.protobuf.timestamp_pb2 as timestamp_pb2 import datetime def create_flight(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub flightsStub = a_rpc_pb2_grpc.FlightsStub(channel) @@ -24,31 +36,35 @@ def create_flight(): # Create template templateRequest = template_pb2.DefaultTemplateRequest() - templateRequest.Protocol = "FLIGHT_PROTOCOL" - templateRequest.Revision = 1 + templateRequest.protocol = "FLIGHT_PROTOCOL" + templateRequest.revision = 1 template = templatesStub.getDefaultTemplate(templateRequest) - template.Name = "ABC Flight Ticket" - template.Description = "Quickstart Flights" - template.Timezone = "Europe/London" + template.name = "ABC Flight Ticket" + template.description = "Quickstart Flights" + template.timezone = "Europe/London" # Make a note of the id for creating the flight designator - templateId = templatesStub.createTemplate(template) + try: + response = templatesStub.createTemplate(template) + print("Template " + response.id + " successfully created") + except grpc.RpcError as e: + print("Failed to create template", e.details()) + # Create flight flight = flight_pb2.Flight() - flight.CarrierCode = "" - flight.FlightNumber = "1234" - flight.BoardingPoint = "ATH" - flight.DeplaningPoint = "TLV" + flight.carrierCode = "" + flight.flightNumber = "1234" + flight.boardingPoint = "ATH" + flight.deplaningPoint = "TLV" - departureDate = datetime.datetime.strptime( - "10/9/2023", "%d/%m/%Y").timestamp() + departureDate = datetime.datetime.now(datetime.timezone.utc) departureTime = datetime.time(13, 0, 0) - flight.DepartureDate = departureDate - flight.ScheduledDepartureTime = departureTime - flight.PassTemplateId = templateId.Id + flight.departureDate = departureDate + flight.scheduledDepartureTime = departureTime + flight.passTemplateId = response.id response = flightsStub.createFlight(flight) print(response) diff --git a/flights/delete-airport.py b/flights/delete-airport.py index 8fe3555..c4d4f10 100644 --- a/flights/delete-airport.py +++ b/flights/delete-airport.py @@ -1,23 +1,35 @@ import grpc -import io.flights.airport_pb2 as airport_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.flights.airport_pb2 as airport_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc def delete_airport(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub flightsStub = a_rpc_pb2_grpc.FlightsStub(channel) # Delete airport airport = airport_pb2.Port() - airport.AirportCode = "YYY" + airport.airportCode = "YYY" response = flightsStub.deletePort(airport) print(response) diff --git a/flights/delete-carrier.py b/flights/delete-carrier.py index 014797d..e434965 100644 --- a/flights/delete-carrier.py +++ b/flights/delete-carrier.py @@ -1,23 +1,35 @@ import grpc -import io.flights.carrier_pb2 as carrier_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.flights.carrier_pb2 as carrier_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc def delete_carrier(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub flightsStub = a_rpc_pb2_grpc.FlightsStub(channel) # Delete carrier carrier = carrier_pb2.Carrier() - carrier.CarrierCode = "YYY" + carrier.carrierCode = "YYY" response = flightsStub.deleteCarrier(carrier) print(response) diff --git a/flights/delete-flight-designator.py b/flights/delete-flight-designator.py index 54a66de..a89922b 100644 --- a/flights/delete-flight-designator.py +++ b/flights/delete-flight-designator.py @@ -1,26 +1,38 @@ import grpc -import io.flights.flight_designator_pb2 as flight_designator_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.flights.flight_designator_pb2 as flight_designator_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc import datetime def delete_flight_designator(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) # Create a stub flightsStub = a_rpc_pb2_grpc.FlightsStub(channel) # Delete flight designator flightDesignator = flight_designator_pb2.FlightDesignator() - flightDesignator.CarrierCode = "" - flightDesignator.FlightNumber = "1234" - flightDesignator.Revision = 0 + flightDesignator.carrierCode = "" + flightDesignator.flightNumber = "1234" + flightDesignator.revision = 0 response = flightsStub.deleteFlightDesignator(flightDesignator) print(response) diff --git a/flights/delete-flight.py b/flights/delete-flight.py index 2eb4bea..ab736c6 100644 --- a/flights/delete-flight.py +++ b/flights/delete-flight.py @@ -1,6 +1,6 @@ import grpc -import io.flights.flight_pb2 as flight_pb2 -import io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.flights.flight_pb2 as flight_pb2 +import passkit_io.flights.a_rpc_pb2_grpc as a_rpc_pb2_grpc import datetime @@ -18,16 +18,15 @@ def delete_flight(): # Delete flight flight = flight_pb2.Flight() - flight.CarrierCode = "" - flight.FlightNumber = "1234" - flight.BoardingPoint = "ATH" - flight.DeplaningPoint = "TLV" + flight.carrierCode = "" + flight.flightNumber = "1234" + flight.boardingPoint = "ATH" + flight.deplaningPoint = "TLV" - departureDate = datetime.datetime.strptime( - "10/9/2023", "%d/%m/%Y").timestamp() + departureDate = datetime.datetime.now(datetime.timezone.utc) departureTime = datetime.time(13, 0, 0) - flight.DepartureDate = departureDate - flight.ScheduledDepartureTime = departureTime + flight.departureDate = departureDate + flight.scheduledDepartureTime = departureTime response = flightsStub.deleteFlight(flight) print(response) diff --git a/membership/burn-points.py b/membership/burn-points.py index 1b9eb02..03f6eaf 100644 --- a/membership/burn-points.py +++ b/membership/burn-points.py @@ -1,28 +1,44 @@ import grpc -import io.member.member_pb2 as member_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.member.member_pb2 as member_pb2 +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc def burn_points(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) - # Create members stub + # Access the MembersStub membersStub = a_rpc_pb2_grpc.MembersStub(channel) # Burn Points burnPointsRequest = member_pb2.EarnBurnPointsRequest() - burnPointsRequest.Id = "" # Id of member of points to burn - burnPointsRequest.Points = 100 - burnPointsRequest.SecondaryPoints = 0 - burnPointsRequest.TierPoints = 0 - response = membersStub.burnPoints(burnPointsRequest) - print(response) + burnPointsRequest.id = "" # Id of member of points to burn + burnPointsRequest.points = 100 + burnPointsRequest.secondaryPoints = 0 + burnPointsRequest.tierPoints = 0 + try: + response = membersStub.burnPoints(burnPointsRequest) + print("Member " + response.id + " has burned " + str(burnPointsRequest.points)) + except grpc.RpcError as e: + print("Failed to burn points", e.details()) + burn_points() diff --git a/membership/check-in-member.py b/membership/check-in-member.py index 2855a4a..4f902d5 100644 --- a/membership/check-in-member.py +++ b/membership/check-in-member.py @@ -1,28 +1,41 @@ import grpc -import io.member.member_pb2 as member_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.member.member_pb2 as member_pb2 +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc def check_in(): - # Create channel credentials - credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC + credentials = grpc.ssl_channel_credentials( + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) - # Create members stub + # Access the MembersStub from passkit_io.member membersStub = a_rpc_pb2_grpc.MembersStub(channel) # Check in member checkInRequest = member_pb2.MemberCheckInOutRequest() - checkInRequest.MemberId = "" # Member Id tp check in - checkInRequest.Lat = 0 # Latitude of check in location - checkInRequest.Lon = 0 # Longitude of check in location - checkInRequest.Address = "" # Check in Address - response = membersStub.checkInMember(checkInRequest) - print(response) + checkInRequest.memberId = "" # Member Id tp check in + checkInRequest.lat = 0 # Latitude of check in location + checkInRequest.lon = 0 # Longitude of check in location + checkInRequest.address = "" # Check in Address + try: + response = membersStub.checkInMember(checkInRequest) + print("Member " + response.id + " successfully checked in") + except grpc.RpcError as e: + print("Failed to check in member", e.details()) check_in() diff --git a/membership/check-out-member.py b/membership/check-out-member.py index 84c8be1..8e9bace 100644 --- a/membership/check-out-member.py +++ b/membership/check-out-member.py @@ -1,28 +1,43 @@ import grpc -import io.member.member_pb2 as member_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.member.member_pb2 as member_pb2 +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc def check_out(): - # Create channel credentials - credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() - # Create members stub + # Create SSL credentials for gRPC + credentials = grpc.ssl_channel_credentials( + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) + + # Access the MembersStub from passkit_io.member membersStub = a_rpc_pb2_grpc.MembersStub(channel) # Check out member + + # Check in member checkOutRequest = member_pb2.MemberCheckInOutRequest() - checkOutRequest.MemberId = "" # Member Id tp check out - checkOutRequest.Lat = 0 # Latitude of check out location - checkOutRequest.Lon = 0 # Longitude of check out location - checkOutRequest.Address = "" # Check out Address - response = membersStub.checkOutMember(checkOutRequest) - print(response) + checkOutRequest.memberId = "" # Member Id tp check in + checkOutRequest.lat = 0 # Latitude of check in location + checkOutRequest.lon = 0 # Longitude of check in location + checkOutRequest.address = "" # Check in Address + try: + response = membersStub.checkOutMember(checkOutRequest) + print("Member " + response.id + " successfully checked in") + except grpc.RpcError as e: + print("Failed to check in member", e.details()) check_out() diff --git a/membership/create-program.py b/membership/create-program.py index 9f87a7d..380dd14 100644 --- a/membership/create-program.py +++ b/membership/create-program.py @@ -1,24 +1,43 @@ import grpc -import io.member.program_pb2 as program_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.member +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +from passkit_io.common.project_pb2 import ProjectStatus def create_program(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) - # Create a stub + # Access the MembersStub from passkit_io.member membersStub = a_rpc_pb2_grpc.MembersStub(channel) - program = program_pb2.Program() - program.Name = "Quickstart Program" - program.Status = [1, 4] - response = membersStub.createProgram(program) - print(response) + program = passkit_io.member.get_program_pb2().Program() + program.name = "Quickstart Program" + program.status.append("PROJECT_ACTIVE_FOR_OBJECT_CREATION") + program.status.append("PROJECT_DRAFT") + + + try: + response = membersStub.createProgram(program) + print("Program " + response.id + " successfully created") + except grpc.RpcError as e: + print("Failed to create program", e.details()) create_program() diff --git a/membership/create-tier.py b/membership/create-tier.py index 8fe6e16..0c13b66 100644 --- a/membership/create-tier.py +++ b/membership/create-tier.py @@ -1,47 +1,69 @@ import grpc -import io.member.tier_pb2 as tier_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc -import io.core.a_rpc_templates_pb2_grpc as a_rpc_templates_pb2_grpc -import io.common.template_pb2 as template_pb2 +import passkit_io +import passkit_io.core.a_rpc_templates_pb2 +import passkit_io.core.a_rpc_templates_pb2_grpc as a_rpc_templates_pb2_grpc +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.core +import passkit_io.common.template_pb2 as template_pb2 def create_tier(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) - # Create members stub + # Access the MembersStub from passkit_io.member membersStub = a_rpc_pb2_grpc.MembersStub(channel) - # Create templates stub templatesStub = a_rpc_templates_pb2_grpc.TemplatesStub(channel) # Create template templateRequest = template_pb2.DefaultTemplateRequest() - templateRequest.Protocol = "MEMBERSHIP" - templateRequest.Revision = 1 + templateRequest.protocol = "MEMBERSHIP" + templateRequest.revision = 1 template = templatesStub.getDefaultTemplate(templateRequest) - template.Name = "Quickstart Base Tier" - template.Description = "Quickstart Base Tier Pass" - template.Timezone = "Europe/London" + template.name = "Quickstart Base Tier" + template.description = "Quickstart Base Tier Pass" + template.timezone = "Europe/London" - templateId = templatesStub.createTemplate(template) + try: + response = templatesStub.createTemplate(template) + print("Template " + response.id + " successfully created") + except grpc.RpcError as e: + print("Failed to create template", e.details()) # Create tier - tier = tier_pb2.Tier() - tier.Id = "base" - tier.Name = "Quickstart Base Tier" - tier.PassTemplateId = templateId.Id - tier.ProgramId = "" # Get from dashboard or createProgram call - tier.Timezone = "Europe/London" - response = membersStub.createTier(tier) - print(response) + tier = passkit_io.member.get_tier_pb2().Tier() + tier.id = "base" + tier.tierIndex = 1 + tier.name = "Quickstart Base Tier" + tier.passTemplateId = response.id + tier.programId = "" # Get from dashboard or createProgram call + tier.timezone = "Europe/London" + + try: + response = membersStub.createTier(tier) + print("Tier " + response.id + " successfully created") + except grpc.RpcError as e: + print("Failed to create tier", e.details()) create_tier() diff --git a/membership/delete-member.py b/membership/delete-member.py index a158479..1330973 100644 --- a/membership/delete-member.py +++ b/membership/delete-member.py @@ -1,25 +1,39 @@ import grpc -import io.member.member_pb2 as member_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.member.member_pb2 as member_pb2 +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc def delete_member(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) - # Create members stub + # Access the MembersStub membersStub = a_rpc_pb2_grpc.MembersStub(channel) # Delete member member = member_pb2.Member() - member.Id = "" # Id of member to delete - response = membersStub.deleteMember(member) - print(response) - + member.id = "7KrZB9i90py1ExNjRQ5P0H" # Id of member to delete + try: + membersStub.deleteMember(member) + print("Member has been deleted") + except grpc.RpcError as e: + print("Failed to delete member", e.details()) delete_member() diff --git a/membership/earn-points.py b/membership/earn-points.py index bd9c842..f9b8866 100644 --- a/membership/earn-points.py +++ b/membership/earn-points.py @@ -1,28 +1,43 @@ import grpc -import io.member.member_pb2 as member_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.member.member_pb2 as member_pb2 +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc def earn_points(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) - # Create members stub + # Access the MembersStub membersStub = a_rpc_pb2_grpc.MembersStub(channel) # Earn Points earnPointsRequest = member_pb2.EarnBurnPointsRequest() - earnPointsRequest.Id = "" # Id of member of points to be increased - earnPointsRequest.Points = 100 - earnPointsRequest.SecondaryPoints = 0 - earnPointsRequest.TierPoints = 0 - response = membersStub.earnPoints(earnPointsRequest) - print(response) + earnPointsRequest.id = "41Nq6AvJQzDNtMJgliwB4c" # Id of member of points to earn points + earnPointsRequest.points = 100 + earnPointsRequest.secondaryPoints = 0 + earnPointsRequest.tierPoints = 0 + try: + response = membersStub.earnPoints(earnPointsRequest) + print("Member " + response.id + " has earned " + str(earnPointsRequest.points)) + except grpc.RpcError as e: + print("Failed to earn points", e.details()) earn_points() diff --git a/membership/enrol-member.py b/membership/enrol-member.py index 64dadea..0db04e8 100644 --- a/membership/enrol-member.py +++ b/membership/enrol-member.py @@ -1,33 +1,52 @@ import grpc -import io.member.member_pb2 as member_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc -import io.common.personal_pb2 as personal_pb2 - +import passkit_io +import passkit_io.member +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +from passkit_io.common.personal_pb2 import Person def enrol_member(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) - # Create members stub + # Access the MembersStub from passkit_io.member membersStub = a_rpc_pb2_grpc.MembersStub(channel) - # Create member - member = member_pb2.Member() - member.ProgramId = "" # Get from dashboard or createProgram call - member.TierId = "" # Get from dashboard or createTier call + # Create and enrol a member + member = passkit_io.member.get_member_pb2().Member() + member.programId = "" # Replace with valid program ID + member.tierId = "" # Replace with valid tier ID - person = personal_pb2.Person() - person.DisplayName = "Loyal Larry" - person.EmailAddress = "" + person = Person() + person.displayName = "Percy PassKit" + person.surname = "PassKit" + person.forename = "Percy" + person.emailAddress = "" - member.Person = person - response = membersStub.enrolMember(member) - print(response) + member.person.CopyFrom(person) + # Enrol the member + try: + response = membersStub.enrolMember(member) + print("Member enrolled successfully: See their pass here:https://pub1.pskt.io/" + response.id) + except grpc.RpcError as e: + print("Failed to enrol member:", e.details()) +# Call the function enrol_member() diff --git a/membership/update-member.py b/membership/update-member.py index 65bf6b8..3e97525 100644 --- a/membership/update-member.py +++ b/membership/update-member.py @@ -1,35 +1,50 @@ import grpc -import io.member.member_pb2 as member_pb2 -import io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc -import io.common.personal_pb2 as personal_pb2 +import passkit_io.member.member_pb2 as member_pb2 +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.common.personal_pb2 as personal_pb2 def update_member(): - # Create channel credentials + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC credentials = grpc.ssl_channel_credentials( - root_certificates='certs/certificate.pem', private_key_file='certs/key.pem', certificate_chain_file='certs/ca-chain.pem') + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) - # Create a secure channel - channel = grpc.secure_channel( - 'grpc.pub1.passkit.io' + ':' + '443', credentials) + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) - # Create members stub + # Access the MembersStub membersStub = a_rpc_pb2_grpc.MembersStub(channel) # Update member # More fields can be updated see https://docs.passkit.io/protocols/member/#operation/Members_updateMember for more member = member_pb2.Member() - member.Id = "" # Id of member to update - member.ProgramId = "" # Get from dashboard or createProgram call - member.TierId = "" # Get from dashboard or createTier call + member.id = "" # Id of member to update + member.programId = "" # Get from dashboard or createProgram call + member.tierId = "" # Get from dashboard or createTier call person = personal_pb2.Person() - person.DisplayName = "Loyal Larry" - person.EmailAddress = "" - - member.Person = person - response = membersStub.updateMember(member) - print(response) + person.displayName = "Loyal Larry" + person.emailAddress = "" + + member.person.CopyFrom(person) + try: + response = membersStub.updateMember(member) + print("Member " + response.id + " has been updated ") + except grpc.RpcError as e: + print("Failed to update member", e.details()) update_member() diff --git a/shared/grpcConnection.py b/shared/grpcConnection.py new file mode 100644 index 0000000..e75c329 --- /dev/null +++ b/shared/grpcConnection.py @@ -0,0 +1,44 @@ +import grpc +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as coupons_a_rpc_pb2_grpc +import passkit_io.core.a_rpc_templates_pb2_grpc as a_rpc_templates_pb2_grpc +import passkit_io.event_tickets.a_rpc_pb2_grpc as events_a_rpc_pb2_grpc +import passkit_io.flights.a_rpc_pb2_grpc as flights_a_rpc_pb2_grpc + + +def grpcConnection(): +# Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC + credentials = grpc.ssl_channel_credentials( + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) + + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) + + # Membership Stub + membersStub = a_rpc_pb2_grpc.MembersStub(channel) + + # Coupons Stub + couponsStub = coupons_a_rpc_pb2_grpc.SingleUseCouponsStub(channel) + + # Events Stub + eventStub = events_a_rpc_pb2_grpc.EventTicketsStub(channel) + + # Flights Stub + flightStub = flights_a_rpc_pb2_grpc.FlightsStub(channel) + + # Create templates stub + templatesStub = a_rpc_templates_pb2_grpc.TemplatesStub(channel) + + grpcConnection() diff --git a/shared/grpcConnectionPooling.py b/shared/grpcConnectionPooling.py new file mode 100644 index 0000000..bf0840e --- /dev/null +++ b/shared/grpcConnectionPooling.py @@ -0,0 +1,72 @@ +import grpc +import threading +import passkit_io.member.a_rpc_pb2_grpc as a_rpc_pb2_grpc +import passkit_io.single_use_coupons.a_rpc_pb2_grpc as coupons_a_rpc_pb2_grpc +import passkit_io.core.a_rpc_templates_pb2_grpc as a_rpc_templates_pb2_grpc +import passkit_io.event_tickets.a_rpc_pb2_grpc as events_a_rpc_pb2_grpc +import passkit_io.flights.a_rpc_pb2_grpc as flights_a_rpc_pb2_grpc + +def grpcConnectionPooling(): + # Initialize the channel pool and current index correctly + channel_pool = [] + current_index = 0 # Use an integer directly and control access with a lock + lock = threading.Lock() + + def build_ssl_context(): + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC + return grpc.ssl_channel_credentials( + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) + + def initialize_channels(pool_size): + host = "grpc.pub1.passkit.io" + port = 443 + ssl_context = build_ssl_context() + + for _ in range(pool_size): + channel = grpc.secure_channel(f"{host}:{port}", ssl_context) + channel_pool.append(channel) + + def get_channel(): + nonlocal current_index + with lock: + channel = channel_pool[current_index] + current_index = (current_index + 1) % len(channel_pool) + return channel + + def shutdown_channels(): + for channel in channel_pool: + channel.close() + channel_pool.clear() + + pool_size = 5 + initialize_channels(pool_size) + try: + channel = get_channel() + # Membership Stub + membersStub = a_rpc_pb2_grpc.MembersStub(channel) + + # Coupons Stub + couponsStub = coupons_a_rpc_pb2_grpc.SingleUseCouponsStub(channel) + + # Events Stub + eventStub = events_a_rpc_pb2_grpc.EventTicketsStub(channel) + + # Flights Stub + flightStub = flights_a_rpc_pb2_grpc.FlightsStub(channel) + + # Create templates stub + templatesStub = a_rpc_templates_pb2_grpc.TemplatesStub(channel) + finally: + shutdown_channels() + grpcConnectionPooling() diff --git a/shared/resend-welcome-email.py b/shared/resend-welcome-email.py new file mode 100644 index 0000000..1dedbb1 --- /dev/null +++ b/shared/resend-welcome-email.py @@ -0,0 +1,40 @@ +import grpc +import passkit_io.core.a_rpc_distribution_pb2_grpc as distribution_pb2_grpc +import passkit_io.common.distribution_pb2 as distribution_pb2 + + +def resend_welcome_email(): + # Read the CA, certificate, and private key files + with open('../certs/ca-chain.pem', 'rb') as ca_file: + root_certificates = ca_file.read() + + with open('../certs/certificate.pem', 'rb') as cert_file: + certificate_chain = cert_file.read() + + with open('../certs/key.pem', 'rb') as key_file: + private_key = key_file.read() + + # Create SSL credentials for gRPC + credentials = grpc.ssl_channel_credentials( + root_certificates=root_certificates, + private_key=private_key, + certificate_chain=certificate_chain + ) + + # Create a secure gRPC channel + channel = grpc.secure_channel('grpc.pub1.passkit.io:443', credentials) + + # Access the distributionStub from passkit_io.member + distributionStub = distribution_pb2_grpc.DistributionStub(channel) + + emailRequest = distribution_pb2.EmailDistributionRequest() + emailRequest.id = "" + emailRequest.protocol = "MEMBERSHIP" + + try: + response = distributionStub.sendWelcomeEmail(emailRequest) + print("Resent welcome email" ) + except grpc.RpcError as e: + print("Failed to resend welcome email", e.details()) + +resend_welcome_email()