def _get_vimeo_client(settings):
v = vimeo.VimeoClient(key=settings.VIMEO_CLIENT_ID,
secret=settings.VIMEO_SECRET_CLIENT_ID)
token = v.load_client_credentials()
authenticated_client = vimeo.VimeoClient(
token=token,
key=settings.VIMEO_CLIENT_ID,
secret=settings.VIMEO_SECRET_CLIENT_ID)
return authenticated_client
def initializeVimeoClient(self):
import vimeo
if len(sys.modules["__main__"].settings.getSetting(
"oauth_token_secret")) > 0 and len(
sys.modules["__main__"].settings.getSetting(
"oauth_token")) > 0:
sys.modules["__main__"].client = vimeo.VimeoClient(
token=sys.modules["__main__"].settings.getSetting(
"oauth_token").encode('ascii'),
token_secret=sys.modules["__main__"].settings.getSetting(
"oauth_token_secret").encode('ascii'))
else:
sys.modules["__main__"].client = vimeo.VimeoClient()
def upload_baptism_to_vimeo(config, video_path, metadata):
""" uploads the video to vimeo using the credentials stored in config """
import vimeo
vimeo_handle = vimeo.VimeoClient(token=config["vimeo"]["token"],
key=config["vimeo"]["key"],
secret=config["vimeo"]["secret"])
video_uri = vimeo_handle.upload(video_path)
vimeo_handle.patch(video_uri,
data={
'name':
"Zur Erinnerung " + "an die Taufe am " +
metadata["date"].strftime("%d.%m.%Y"),
'description':
'',
'privacy': {
'view': 'password'
},
'password':
create_baptism_video_password(metadata)
})
video_uri = video_uri.replace("s", "")
return video_uri
def updateVimeoVideoDetails(video_id, title, description):
if video_id:
v = vimeo.VimeoClient(token=settings.VIMEO_TOKEN, )
postdata = {'name': title, 'description': description}
vimeoUrl = '/videos/%s' % int(video_id)
json_data = v.patch(vimeoUrl, data=postdata)
return 'Updated Successfully'
def get_vimeo_videos(request):
subscription = Subscription.objects.get(user=request.user)
if not subscription:
return Response({"message": "Invalid subscription"},
status=status.HTTP_401_UNAUTHORIZED)
v = vimeo.VimeoClient(token=subscription.vimeo_token,
key=settings.VIMEO_CLIENT_IDENTIFIED,
secret=settings.VIMEO_CLIENT_SECRET)
try:
video_list = v.get(
'/me/videos?per_page=100&fields=uri,name,pictures.sizes')
if video_list.status_code == 200:
return Response(video_list.json().get('data'),
status=status.HTTP_200_OK)
elif video_list.status_code == 401:
return Response({'message': video_list.json().get('error')},
status=status.HTTP_401_UNAUTHORIZED)
else:
logger.exception(
"error getting Videos from Vimeo. Error Code: {0}, Error Message: {1}"
.format(video_list.status_code,
video_list.json().get('error')))
return Response({"message": "Failed to load video list"},
status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
logger.exception(ex)
return Response({"message": ex.message},
status=status.HTTP_400_BAD_REQUEST)
def post_file():
if request.method == 'POST':
# construct request
client = vimeo.VimeoClient(
token=access_token,
key=client_id,
secret=client_secret
)
try:
# unpack payload
data = json.loads(request.form.get('data'))
name = data.get('name')
description = data.get('description')
filename = data.get('filename')
projection = data.get('projection')
stereo_format = data.get('stereo_format')
file = request.files.get('file')
if file and filename:
file.save(filename)
uri = client.upload(filename, data={
'name': name,
'description': description,
'spatial.projection': projection,
'spatial.stereo_format': stereo_format
})
os.remove(filename)
return jsonify({'res': {'uri': uri}})
else:
return jsonify({'err': 'No file provided'})
except Exception as err:
return jsonify({'err': str(err)})
def authorize_vimeo_success(request):
subscription = Subscription.objects.get(user=request.user)
if not subscription:
return HttpResponse('Unauthorized', status=401)
if not request.GET.get('error') and request.GET.get('state') == 'xyz':
v = vimeo.VimeoClient(
key=settings.VIMEO_CLIENT_IDENTIFIED,
secret=settings.VIMEO_CLIENT_SECRET)
token, user, scope = v.exchange_code(request.GET.get('code'),
settings.BASE_URL + '/auth/vimeo/success')
subscription.vimeo_token = token
subscription.vimeo_scope = scope
subscription.save()
# try and populate feed titles and images
feeds_without_titles = Feed.objects.filter(owner=request.user, provider__name='vimeo', video_thumbnail='')
for feed in feeds_without_titles:
title, image = get_vimeo_title_and_thumbnail_with_subscription(feed.video_id, subscription)
if title:
feed.video_title = title
feed.video_thumbnail = image
feed.save()
return redirect('/app/dashboard')
def course_detail(request ):
v = vimeo.VimeoClient(
token=settings.VIMEO_ACCESS_TOKEN,
key=settings.VIMEO_CLIENT_ID,
secret=settings.VIMEO_CLIENT_SECRET
)
# course_obj = vimeo_project.objects.all()
course_obj = sorted(vimeo_project.objects.all(), key=lambda n: (n.name.split('Module ')[1]))
# about_me = v.get('/me/projects?sort=date&direction=desc', params={"fields": "uri, name"})
# for i in about_me.json()['data']:
# about_me2 = v.get(str(i['uri'])+str('/videos'), params={"fields": "name, link, embed.html, duration, description, pictures.sizes", "per_page":100, "page": 2 })
# try:
# if not vimeo_project.objects.filter(name=i['name']).exists():
# q_2 = vimeo_project(name=i['name'], url=i['uri'])
# q_2.save()
# else:
# q_2 = vimeo_project.objects.get(name=i['name'])
# for x in about_me2.json()['data']:
# if vimeo_videos.objects.filter(project=vimeo_project.objects.get(name=i['name']), url=x['link']).exists():
# q_1 = vimeo_videos.objects.filter(project=vimeo_project.objects.get(name=i['name']), url=x['link']).update(name=x['name'])
# # q_1 = vimeo_videos(project=vimeo_project.objects.get(name=i['name']), url=x['link'], html=x['embed']['html'], duration=x['duration'], thub_url=x['pictures']['sizes'][2])
# # q_1.save()
# except:
# pass
return render(request, 'course_learning/coursedetails.html', { 'course_obj':course_obj})
def upload(path):
config_file = os.path.dirname(os.path.realpath(__file__)) + '/config.json'
config = json.load(open(config_file))
if 'client_id' not in config or 'client_secret' not in config:
raise Exception(
'We could not locate your client id or client secret ' + 'in `' +
config_file + '`. Please create one, and ' +
'reference `config.json.example`.')
# Instantiate the library with your client id, secret and access token
# (pulled from dev site)
client = vimeo.VimeoClient(token=config['access_token'],
key=config['client_id'],
secret=config['client_secret'])
# Create a variable with a hard coded path to your file system
# TODO: accept via argparse
file_name = '<full path to a video on the filesystem>'
print('Uploading: %s' % file_name)
try:
# Upload the file and include the video title and description.
uri = client.upload(
file_name,
data={
'name':
'Vimeo API SDK test upload',
'description':
"This video was uploaded through the Vimeo API's " +
"Python SDK."
})
# Get the metadata response from the upload and log out the Vimeo.com url
video_data = client.get(uri + '?fields=link').json()
print('"%s" has been uploaded to %s' % (file_name, video_data['link']))
# Make an API call to edit the title and description of the video.
client.patch(uri,
data={
'name':
'Vimeo API SDK test edit',
'description':
"This video was edited through the Vimeo API's " +
"Python SDK."
})
print('The title and description for %s has been edited.' % uri)
# Make an API call to see if the video is finished transcoding.
video_data = client.get(uri + '?fields=transcode.status').json()
print('The transcode status for %s is: %s' %
(uri, video_data['transcode']['status']))
except vimeo.exceptions.VideoUploadFailure as e:
# We may have had an error. We can't resolve it here necessarily, so
# report it to the user.
print('Error uploading %s' % file_name)
print('Server reported: %s' % e.message)
def upload(filename):
ident, secret, token = auth('vimeo',
['client_id', 'client_secret', 'token'])
api = vimeo.VimeoClient(token=token, key=ident, secret=secret)
print 'Uploading...'
api.upload(filename)
print 'Done!'
def __init__(self, video_amount: int = None):
self.default_params = {
'per_page':
video_amount if video_amount else settings.SEARCH_VIMEO_AMOUNT
}
self.client = vimeo.VimeoClient(token=settings.VIMEO_ACCESS_TOKEN,
key=settings.VIMEO_CLIENT_ID,
secret=settings.VIMEO_CLIENT_SECRET)
def Vimeo_Upload(video):
v = vimeo.VimeoClient(token=config.TOKEN,
key=config.CLIENT_ID,
secret=config.CLIENT_SECRET)
about_me = v.get('/me')
assert about_me.status_code == 200
video_uri = v.upload(video.file)
video_uri = (video_uri.split('s')[0] + video_uri.split('s')[1])
return video_uri
def auth(self, creds):
client = vimeo.VimeoClient(
key=creds['client_id'],
secret=creds["client_secret"],
token=creds["access"],
token_secret=creds["access_secret"],
format="json")
return client
def authorize_vimeo(request):
if not request.user.get_subscription():
return HttpResponse('Unauthorized', status=401)
v = vimeo.VimeoClient(
key=settings.VIMEO_CLIENT_IDENTIFIED,
secret=settings.VIMEO_CLIENT_SECRET)
vimeo_authorization_url = v.auth_url(['public', 'private'],
settings.BASE_URL + '/auth/vimeo/success', 'xyz')
return redirect(vimeo_authorization_url)
def getVideo(id):
client = vimeo.VimeoClient(
token='1a028b267f6e92a4f90389b031d33b60',
key='a591a007d8a09bc7fd57c50d325180224bdffa25',
secret=
'4IWycSdPpr9m73k/5TTQF+WBUV631kUtK4EQETBVhzmweZXTiOZp7jYYSP3cEXrzSLfS2IrQh1lnVPevXvZPbyRJV3UKWYwfhzHr68nUHSHg+Srm3BvqOiPvc8gAjWH3'
)
res = client.get('/videos/' + id[18:])
jsonData = res.json()
return jsonData
def add_vimeo(url, uri):
personal_token: str = os.getenv("PAT")
client_id: str = os.getenv("CID")
secret_key: str = os.getenv("SAT")
video = f"https://api.vimeo.com/videos{url[uri:]}"
client = vimeo.VimeoClient(token=personal_token,
key=client_id,
secret=secret_key)
response = client.get(video)
return vimeo_to_db(
response.json()) if response.status_code == 200 else "Invalid URL"
def get_video(self):
if self.vimeo_id:
v = vimeo.VimeoClient(token=VIMEO_ACCESS_TOKEN,
key=VIMEO_CLIENT_KEY,
secret=VIMEO_CLIENT_SECRET)
response = v.get("/videos/%s" % (self.vimeo_id, ), params={})
data = response.json()
else:
data = None
return data
def requestOAuth():
oauth2Server.callback = processResoponse
t = threading.Thread(target=oauth2Server.run, args=())
t.start()
v = vimeo.VimeoClient(key=KEY, secret=SECRET)
vimeo_authorization_url = v.auth_url(['public', 'private', 'upload'],
'http://localhost:8081', '')
webbrowser.open(vimeo_authorization_url)
def conectarVimeo(tokenF, keyF, secretF):
v = vimeo.VimeoClient(token=tokenF, key=keyF, secret=secretF)
print(tokenF)
# Make the request to the server for the "/me" endpoint.
about_me = v.get('/me')
# Make sure we got back a successful response.
#assert about_me.status_code == 200
# Load the body's JSON data.
respostaStatus = about_me.json()
print(respostaStatus)
return respostaStatus
def upload(vimeoObj, VidLocation, titleVid, description, tag, count=1):
if count == 5:
print "Retring in upload failed"
return
v = vimeo.VimeoClient(token=vimeoObj, key=KEY, secret=SECRET)
try:
video_uri = v.upload(VidLocation)
v.patch(video_uri, data={'name': titleVid, 'description': description})
print "upload complete"
except:
print "Upload failed. Retrying..."
upload(vimeoObj, VidLocation, titleVid, description, tag, count + 1)
def sync():
personal_token: str = os.getenv("PAT")
client_id: str = os.getenv("CID")
secret_key: str = os.getenv("SAT")
uri = '/me/videos'
client = vimeo.VimeoClient(token=personal_token,
key=client_id,
secret=secret_key)
response = client.get(uri)
if response.status_code == 200:
data = response.json()
return (add_items(data['data']))
def list(self, request, *args, **kwargs):
endpoint = kwargs.get('endpoint', None)
if endpoint == '' or endpoint == None:
return Response(False)
v = vimeo.VimeoClient(token=VIMEO_ACCESS_TOKEN,
key=VIMEO_CLIENT_KEY,
secret=VIMEO_CLIENT_SECRET)
response = v.get("/%s" % (endpoint, ), params=dict(request.GET))
data = response.json()
return Response(data, status=response.status_code)
def processResoponse(CODE_FROM_URL):
"""This section completes the authentication for the user."""
v = vimeo.VimeoClient(key=KEY, secret=SECRET)
# You should retrieve the "code" from the URL string Vimeo redirected to. Here that's named CODE_FROM_URL
try:
token, user, scope = v.exchange_code(CODE_FROM_URL,
'http://localhost:8081')
print token
print scope
except vimeo.auth.GrantFailed:
print "tokening failed"
print caller
caller.vimeoObj = token
def get_client(config):
if 'client_id' not in config or 'client_secret' not in config:
raise Exception(
'We could not locate your client id or client secret ' + 'in `' +
config_file + '`. Please create one, and ' +
'reference `config.json.example`.')
# Instantiate the library with your client id, secret and access token
# (pulled from dev site)
client = vimeo.VimeoClient(token=config['access_token'],
key=config['client_id'],
secret=config['client_secret'])
return client
def get_vimeo_title_and_thumbnail_with_subscription(video_id, subscription):
if not subscription.vimeo_token:
return
v = vimeo.VimeoClient(token=subscription.vimeo_token,
key=settings.VIMEO_CLIENT_IDENTIFIED,
secret=settings.VIMEO_CLIENT_SECRET)
video = v.get(
'/me/videos/{0}?fields=uri,name,pictures.sizes'.format(video_id))
if video.status_code == 200:
try:
video_json = video.json()
return video_json.get('name'), video_json.get('pictures').get(
'sizes')[3].get('link')
except:
pass
return "", ""
def getVideos():
v = vimeo.VimeoClient(
token="81e7f05a8bdd4aeca46f464705c877a3",
key="4ae71a994fd01243ec81198daba42fe517832820",
secret=
"8UbigGyYMe1/EfEecJxL/n5QneEeSPoBm2uKN+mTZnSyn9oMWeIIuBZ6eEGV6jJnAWQOfcL4L6GPwcAVDrU7/MWso4rhJgz585I+DwQdSRLOlp+/BZ8QDk0SNDUt64Kw"
)
about_me = v.get(
'/me/videos?per_page=100&filter=playable&query=Menni&sort=date&weak_search=true',
params={"fields": "link, name, pictures"})
assert about_me.status_code == 200
jsonData = about_me.json()
strData = json.dumps(jsonData)
dataLoc = strData.find("data") + 7
strData = strData[dataLoc:len(strData)]
return strData
def post(self, request):
key = getattr(settings, 'VIMEO_CLIENT_ID', '')
secret = getattr(settings, 'VIMEO_CLIENT_SECRET_ID', '')
token = getattr(settings, 'VIMEO_TOKEN', '')
v = vimeo.VimeoClient(key=key, secret=secret, token=token)
file_path = self.handle_uploaded_file(request.data['video'])
try:
video_uri = v.upload(file_path)
if video_uri:
a = video_uri.split('/')
dt.sleep(5)
return Response('https://vimeo.com/{}'.format(a[-1]))
else:
return Response(False)
except OSError:
pass
finally:
os.remove(file_path)
def demo(request):
v = vimeo.VimeoClient(
token=settings.VIMEO_ACCESS_TOKEN,
key=settings.VIMEO_CLIENT_ID,
secret=settings.VIMEO_CLIENT_SECRET
)
about_me = v.get('/me/projects/828255/videos?sort=date&direction=desc')
# about_me = v.get('/me/projects', params={ "per_page":100, "page": 1 })
# lst = ""
# for i in vimeo_videos.objects.all():
# try:
# i.name.split('Slide')[1].strip()
# except:
# lst += str(i.id) + "<br>"
return JsonResponse(about_me.json(), safe=False)
def connect_to_vimeo(config_file):
config = json.load(open(config_file))
if 'client_id' not in config or 'client_secret' not in config:
raise ConnectionError(
'No client_id or client_secret found in {}'.format(config_file))
vimeo_client = vimeo.VimeoClient(token=config['access_token'],
key=config['client_id'],
secret=config['client_secret'])
about_me = vimeo_client.get(
'/me') # Make the request to the server for the "/me" endpoint.
if about_me.status_code != 200:
raise ValueError('Cannot get /me, status is {}'.format(
about_me.status_code))
return vimeo_client
def refresh_view_count(_id=None):
from velo.gallery.models import Video
videos = Video.objects.filter(status=1).order_by('-id')
if _id:
videos = videos.filter(id=_id)
if not datetime.date.today().day == 1:
videos = videos[:20] # Daily we update only last 20 video counters, but once in month we update all.
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"
storage = Storage("gallery/youtube-oauth2.json")
credentials = storage.get()
youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
http=credentials.authorize(httplib2.Http()))
v = vimeo.VimeoClient(token=settings.VIMEO_TOKEN, key=settings.VIMEO_KEY, secret=settings.VIMEO_SECRET)
for video in videos:
if video.kind == 1: # youtube
video_response = youtube.videos().list(
id=video.video_id,
part='statistics'
).execute()
item = video_response.get('items')[0]
video.view_count = int(item.get('statistics').get('viewCount'))
# TODO: Add YOUTUBE VIDEO Availability checker
elif video.kind == 2: # vimeo
video_response = v.get('/videos/%s' % video.video_id)
if video_response.status_code == 200:
item = video_response.json()
video.view_count = int(item.get('stats').get('plays'))
if item.get('status') != 'available':
video.status = 0
elif video_response.status_code == 404:
video.status = 0
video.save()
