def retrieve(self, request, pk=None, *args, **kwargs):
"""Overridden GET For Particular Directory Informations about Shared & its Tags"""
try:
file_view_object = FileView()
directory_request = pk
directory_info = crud.get(self.table, "*",
"where id = %s" % (directory_request))
directory_info = directory_info and directory_info[0]
shared_info = crud.get(
ShareView.table, "*",
"where directory_id = %s " % (directory_request))
tag_info = crud.execute(
"select tag_id from file_manager_directory_tags where directory_id = %s "
% (directory_request))
tag_info = zip(*tag_info)[0] if tag_info and tag_info[0] else []
file_info = crud.get(
FileView.table, "*",
"where directory_id = {0}".format(directory_request))
file_data = file_view_object.get_file_data(request, file_info)
sub_directories = crud.get(
self.table, "*",
"where parent_id=" + str(directory_info['id']))
if directory_info:
directory_info.update({
"shared_dirs": shared_info,
"tags": tag_info,
"file_ids": file_data,
"sub_directories": sub_directories
})
return Response(directory_info)
except Exception as e:
return Response(e)
def pdf_editor(self, request, pk=None, *args, **kwargs):
file_res = File.objects.get(id=pk)
decrypt_file(
os.path.join(settings.MEDIA_ROOT + str(
crud.get(self.table, "*", 'where id=' +
pk)[0].get('owner_id')) + '/' +
base64.b16encode(file_res.modified_file_name)),
os.path.join(settings.MEDIA_ROOT + file_res.modified_file_name),
'123')
os.chdir(settings.MEDIA_ROOT + str(
crud.get(self.table, "*", 'where id=' + pk)[0].get('owner_id')))
os.system('unoconv --format=pdf ' +
os.path.join(settings.MEDIA_ROOT +
file_res.modified_file_name))
file = open(
settings.MEDIA_ROOT + file_res.modified_file_name.split('.')[0] +
'.pdf', 'rb')
response = HttpResponse(FileWrapper(file),
content_type='application/pdf')
response['Content-Disposition'] = 'inline; filename="{}"'.format(
file_res.modified_file_name)
os.remove(
os.path.join(settings.MEDIA_ROOT + file_res.modified_file_name))
os.remove(settings.MEDIA_ROOT +
file_res.modified_file_name.split('.')[0] + '.pdf')
return response
def activity_data(self,request,activity_id=None, *args,**kwargs):
activity_type=request.data.get(config.type)
print "ACTIVITY TYPE +++===",activity_type
if activity_id and activity_type is not int :
if activity_type==config.dir:
data = Log.objects.get(directory_id=activity_id)
elif activity_type==config.file:
data = Log.objects.get(file_id=activity_id)
elif activity_type=="wf":
data = Log.objects.get(workflow_id=activity_id)
elif activity_type==config.version:
version_data=crud.execute("select activity_log_activity.id from activity_log_log inner join activity_log_activity on activity_log_log.id=activity_log_activity.log_id where activity_log_activity.name like '%version%' and file_id="+activity_id)
version_data = zip(*version_data)
if version_data:
if len(version_data[0])>1:
response = crud.get(ActivityView.table,"*", "where id in {}".format(version_data[0]))
else:
response = crud.get(ActivityView.table,"*", "where id={}".format(version_data[0][0]))
data=response[0]
return Response(response)
else:
logger.debug(config.Data_before_update_not_awailable)
return Response({config.status:0})
if data:
response_data = LogSerializer(data)
return Response(response_data.data)
else:
data=[]
else:
data=[]
return Response(data)
def totaldocuments(self, request, *args, **kwargs):
"""Total Documents for an Owner/User in Dashboard"""
total_documents_userid = request.user.id
my_total_documents = crud.get(
"file_manager_file", ["count(id) as my_file"],
"where owner_id = %s" % (total_documents_userid))
my_total_documents = my_total_documents and my_total_documents[0]
my_shared_documents = crud.execute(
"SELECT share_id FROM file_manager_share_user_ids WHERE user_id = %s"
% (total_documents_userid))
my_shared_documents = zip(*my_shared_documents)
try:
my_shared_documents1 = crud.get(
"file_manager_share", ["count(file_id)"],
" WHERE file_id is not null and id in {}".format(
my_shared_documents[0])
) if len(my_shared_documents) > 1 else crud.get(
"file_manager_share", ["count(file_id)"],
" WHERE file_id is not null and id = {}".format(
my_shared_documents[0][0]))
except Exception as err:
return Response(err)
my_shared_documents1 = my_shared_documents1 and my_shared_documents1[0]
my_total_documents.update(my_shared_documents1)
return Response(my_total_documents)
def get_child_dirs(self, request, pk=None, *args, **kwargs):
file_view_object = FileView()
# child_object = crud.get(self.table,c.all,"where
# parent_id={}".format(pk))
# child_object = Directory.objects.filter(parent_id=pk,owner_id=request.user.id).order_by(c.name)
files = crud.get(
'file_manager_file', "*",
"where directory_id ={0} and owner_id = {1}".format(
int(pk), request.user.id))
child_object = crud.get(
self.table, "*",
"where parent_id={0} and owner_id={1} order by name".format(
int(pk), request.user.id))
child_dirs = map(
lambda i: i.update({
'file_ids':
file_view_object.get_file_data(request, files),
'shared_dirs':
self.get_directory_data(request, int(pk)),
'sub_directories': [
item for sublist in crud.execute(
"select id from file_manager_directory where parent_id = {0}"
.format(i['id'])) for item in sublist
]
}), child_object)
logger.debug("Dictionary:: get_child_dirs: Child Object {} ".format(
child_object))
# child_dirs = DirectorySerializer(child_object, many=True)
# logger.debug(
# "Dictionary:: get_child_dirs: Child DIrs{}".format(child_dirs))
return Response(child_object)
def retrieve(self, request, pk=None):
# workflow_obj = crud.get(self.table,crud.fetch_query(config.workflow,config. ).format(pk))
workflow_obj = crud.get(self.table, "*", "WHERE id={}".format(pk))
logger.debug(
"\n\nNTWF WF:Retrieve - Workflow Object {} ".format(workflow_obj))
workflow_obj = workflow_obj and workflow_obj[0]
transition_obj = crud.get(
TransitionViewSet.table, "*", "WHERE workflow_id={}".format(pk))
logger.debug(
"\n\nNTWF WF:Retrieve - Transition Object {} ".format(transition_obj))
workflow_obj.update({"workflow_transition": transition_obj})
return Response(workflow_obj)
def main():
while True:
print(":=="*20)
print("\t\tCONSOLE CRUD WITH SQLITE3")
print(":=="*20)
print("[C]REATE NEW DATABASE")
print("[D]ROP DATABASE")
print("[U]SE DATABASE")
print("[E]xit")
print(":=="*20)
try:
opt = input('Select one option:\n')
if opt.upper() == 'C':
crud.clear()
db.createDB()
elif opt.upper() == 'D':
db.dropDB()
elif opt.upper() == 'U':
while True:
print("[1] Insert new record")
print("[2] Show all records")
print("[3] Update a record")
print("[4] Delete a record")
print("[5] Search a record")
print("[6] Exit")
print(":=="*20)
try:
option = int(input('Select a option:\n'))
if option == 1:
crud.clear()
crud.create()
if option == 2:
crud.clear()
crud.get()
if option == 3:
crud.update()
elif option == 4:
crud.delete()
elif option == 6:
crud.clear()
break
except:
print('Option invalid!')
elif opt.upper() == 'E':
break
except:
print('Option invalid!')
def save_editor(self, request, pk=None, *args, **kwargs):
file_res = File.objects.get(id=pk)
decrypt_file(
os.path.join(settings.MEDIA_ROOT + str(
crud.get(self.table, "*", 'where id=' +
pk)[0].get('owner_id')) + '/' +
base64.b16encode(file_res.modified_file_name)),
os.path.join(settings.MEDIA_ROOT + file_res.modified_file_name),
'123')
self.org_data = convert(settings.MEDIA_ROOT +
FileSerializer(File.objects.get(
id=pk)).data.get('modified_file_name'))
os.remove(
os.path.join(settings.MEDIA_ROOT + file_res.modified_file_name))
if self.org_data != request.data:
# Activity log
request_data = {}
param = {'field': 'file_id', 'file_id': pk, 'label': 'version'}
track_fields = {
c.can_read: c.read,
c.can_write: c.write,
c.can_delete: c.delete
}
request_data.update({'user_id': request.user.id})
log_view = LogView()
log_view.generate_log(request_data, param, "", track_fields)
f = open(
settings.MEDIA_ROOT + str(
crud.get(self.table, "*",
'where id=' + pk)[0].get('owner_id')) + '/' +
file_res.modified_file_name.split('.')[0] + '.html', 'w')
f.write(request.data['data'].encode())
f.close()
os.chdir(settings.MEDIA_ROOT + str(
crud.get(self.table, "*", 'where id=' +
pk)[0].get('owner_id')))
os.system('unoconv --format=' + file_res.name.split('.')[-1] +
' ' + settings.MEDIA_ROOT + str(
crud.get(self.table, "*", 'where id=' +
pk)[0].get('owner_id')) + '/' +
file_res.modified_file_name.split('.')[0] + '.html')
time.sleep(3)
os.remove(settings.MEDIA_ROOT + str(
crud.get(self.table, "*", 'where id=' +
pk)[0].get('owner_id')) + '/' +
file_res.modified_file_name.split('.')[0] + '.html')
encrypt_file(
os.getcwd() + '/' + file_res.modified_file_name,
os.getcwd() + '/' +
base64.b16encode(file_res.modified_file_name), '123')
os.remove(os.getcwd() + '/' + file_res.modified_file_name)
return Response({"hai": 'hai'})
def tag_change(self, pk, requst_data, key):
tags = crud.execute(
"select name, file_manager_tag.id from file_manager_tag inner join file_manager_"
+ key + "_tags on file_manager_tag.id=file_manager_" + str(key) +
"_tags.tag_id where " + key + "_id={}".format(pk))
old_tag = []
new_tag = []
new_tag_ids = {}
old_tag_ids = {}
if tags:
for tag in tags:
old_tag_ids.update({str(tag[0]): tag[1]})
old_tag.append(str(tag[0]))
else:
old_tag = []
directory_update = requst_data
new_tags = directory_update.get('tags')
newTags = ""
directory_update = requst_data
new_tags = directory_update.get(c.tags)
newTags = ""
if new_tags:
new_tags = tuple(new_tags)
if len(new_tags) > 1:
newTags = crud.get("file_manager_tag", ['id,name'],
'where id in ' + str(new_tags))
elif len(new_tags) == 1:
newTags = crud.get("file_manager_tag", ['id,name'],
'where id = ' + str(new_tags[0]))
if newTags:
for nt in newTags:
new_tag_ids.update({str(nt.get(c.name)): nt.get('id')})
new_tag.append(str(nt.get(c.name)))
# else:
def lr_diff(l, r):
return list(set(l).difference(r))
deleted_tag = lr_diff(old_tag, new_tag)
added_tag = set(new_tag).difference(old_tag)
tag_details = {}
tag_details['added_tag'] = added_tag
tag_details['deleted_tag'] = deleted_tag
tag_details['new_tag_ids'] = new_tag_ids
tag_details['old_tag_ids'] = old_tag_ids
tag_details['new_tag'] = new_tag
return tag_details
def get_name(self,table_name,parameters,id):
name=crud.get(table_name,parameters,config.where_id.format(id))
if table_name==config.auth_user:
name=str(name[0].get(parameters[0])+" "+name[0].get(parameters[1])).title()
if table_name==config.auth_group:
name=str(name[0].get(parameters[0])).title()
return name
def retrieve(self, request, pk=None, *args, **kwargs):
"""Overridden GET For Particular File Informations about Shared & its Tags"""
try:
file_request = int(pk)
file_info = crud.get(
self.table, "*",
"where id = %s order by created_date desc" % (file_request))
file_info = file_info and file_info[0]
shared_info = crud.get(ShareView.table, "*",
"where file_id = %s " % (file_request))
tag_info = crud.execute(
"select tag_id from file_manager_file_tags where file_id = %s "
% (file_request))
tag_info = zip(*tag_info)[0] if tag_info and tag_info[0] else []
shared_files = self.get_file_data(request, [file_info])
return Response(file_info)
except Exception as e:
return Response(e)
def list(self, request, *args, **kwargs):
"""Overridden GET For Directory Informations Created by a Particular Owner """
try:
l = {}
response = request.user.id
directory_info = crud.get(self.table, "*",
"where owner_id = " + str(response))
sub_directories = map(
lambda i: i.update({
'sub_directories':
crud.get(self.table, "*", "where parent_id=" + str(i['id'])
),
'file_ids':
crud.get(FileView.table, "*", "where directory_id=" + str(
i['id']))
}), directory_info)
return Response(directory_info)
except Exception as e:
return Response(e)
def get_parent_dirs(self, request, *args, **kwargs):
try:
response = crud.get(
self.table, c.all,
"where owner_id={} and parent_id is null order by name".format(
request.user.id))
sub_directories = map(
lambda i: i.update({
'sub_directories':
crud.get(self.table, "*", "where parent_id=" + str(i['id'])
),
'file_ids':
crud.get(FileView.table, "*", "where directory_id=" + str(
i['id']))
}), response)
logger.debug(
"Files:: get_parent_dirs: Parent Files{}".format(response))
return Response(response)
except Exception as e:
return Response({"error": e})
def get_mytasks(self, request, *args, **kwargs):
"Custom Service for My Tasks in Dashboard for an Owner/User"
my_tasks_userid = request.user.id
my_taks_fileinfo = crud.execute(
"""select id from file_manager_file where workflow_id in(select id from ntwf_workflow where is_template='false' and id in
(select workflow_id from ntwf_transition where auth_user_id = %s ) and active_state_id in (select state_from_id from ntwf_transition) )"""
% (my_tasks_userid))
my_tasks_fileinfo1 = map(
lambda i: crud.get(self.table, "*", "where id = %s" % (i))[0],
my_taks_fileinfo)
return Response(my_tasks_fileinfo1)
def get_mypendingtasks(self, request, *args, **kwargs):
"""My Pending Requests in Dashboard"""
my_pending_tasks_userid = request.user.id
my_pendingtasks_fileinfo = crud.execute(
crud.fetch_query(
c.file_manager,
c.my_pendingtasks_fileinfo).format(my_pending_tasks_userid))
my_pendingtasks_fileinfo1 = map(
lambda i: crud.get(self.table, "*", "where id = %s" % (i[0]))[0],
my_pendingtasks_fileinfo)
return Response(my_pendingtasks_fileinfo1)
def get_parent_files(self, request, *args, **kwargs):
try:
files = crud.get(
self.table, "*",
"where directory_id is null and owner_id = {0} order by created_date desc"
.format(request.user.id))
shared_files = self.get_file_data(request, files)
logger.debug("Files:: get_parent_files: Parent Files{}".format(
shared_files))
return Response(shared_files)
except Exception as e:
return Response({"error": e})
def list(self, request, *args, **kwargs):
"""Overridden GET For File Informations Created by a Particular Owner """
try:
response = request.user.id
file_info = crud.get(
self.table, "*", "where owner_id = " + str(response) +
" order by created_date desc")
shared_files = self.get_file_data(request, file_info)
shared_info = map(
lambda i: i.update({
'tags': [
item for sublist in crud.execute(
"select tag_id from file_manager_file_tags where file_id = %s "
% (i['id'])) for item in sublist
],
'shared_ids':
crud.get(ShareView.table, "*", "where file_id = %s " %
(i['id']))
}), file_info)
return Response(file_info)
except Exception as e:
return Response(e)
def get_directory_data(self, request, parent_id='null'):
l = {}
directories = crud.get(
self.table, "*", "where parent_id = {0} and owner_id = {1}".format(
parent_id, request.user.id))
crud.execute(
"create or replace view directory_share as select ds.id,ds.directory_id,dsu.user_id,dsg.group_id,ds.can_read,ds.can_write,ds.can_delete from file_manager_share as ds left join file_manager_share_group_ids as dsg on ds.id = dsg.share_id left join file_manager_share_user_ids as dsu on ds.id = dsu.share_id where directory_id is not null"
)
directory_share_data = crud.get('directory_share', "*", '')
map(
lambda x: l.get(x.get('directory_id')).get('shared_ids').append(x)
if x.get('directory_id') in l else l.update(
{x.get('directory_id'): {
'shared_ids': [x]
}}), directory_share_data)
map(
lambda (k, v): v.update({
'user_ids':
list(
set(map(lambda fd: fd.get('user_id'), v.get('shared_ids')))
),
'group_ids':
list(
set(map(lambda fd: fd.get('group_id'), v.get('shared_ids'))
))
}), l.iteritems())
tags = map(
lambda f: f.update({
'tags': [
i[0] for i in crud.
execute("select tag_id from {0} where directory_id = {1}".
format("file_manager_directory_tags", f.get('id')))
]
}) if f.get('id') else '', directories)
shared_dirs = map(
lambda f: f.update({'shared_dirs': [l.get(f.get('id'))]}),
directories)
return directories
def download(self, request, pk=None, *args):
file_res = File.objects.get(id=pk)
decrypt_file(
os.path.join(settings.MEDIA_ROOT + str(
crud.get(self.table, "*", 'where id=' +
pk)[0].get('owner_id')) + '/' +
base64.b16encode(file_res.name)),
os.path.join(settings.MEDIA_ROOT + file_res.name), '123')
file = open(settings.MEDIA_ROOT + file_res.name, 'rb')
response = HttpResponse(FileWrapper(file),
content_type=file_res.file_content_type)
response['Content-Disposition'] = 'attachment; filename="{}"'.format(
file_res.name)
os.remove(os.path.join(settings.MEDIA_ROOT + file_res.name))
return response
def edit_file(self, request, pk=None):
file_res = File.objects.get(id=pk)
decrypt_file(
os.path.join(settings.MEDIA_ROOT + str(
crud.get(self.table, "*", 'where id=' +
pk)[0].get('owner_id')) + '/' +
base64.b16encode(file_res.modified_file_name)),
os.path.join(settings.MEDIA_ROOT + file_res.modified_file_name),
'123')
os.chdir(settings.MEDIA_ROOT)
os.system('unoconv --format=xhtml ' + settings.MEDIA_ROOT +
FileSerializer(File.objects.get(
id=pk)).data.get('modified_file_name'))
os.remove(
os.path.join(settings.MEDIA_ROOT + file_res.modified_file_name))
return Response({'contents': data_edit})
def tranform_validation(request):
auth_url= "http://"+request.META.get(config.HTTP_HOST)+config.api_token_auth
data=json.loads(request.body.decode(config.utf8))
username=data.get(config.username)
password=data.get(config.password)
print "data========>",data
print "User name========>",username
try:
request_url =requests.get(config.transform_url+str(username)+'&'+config.password+'='+str(password))
result = json.loads(request_url.text)
print "Result ====-=-=-=-=-=",result
message=result.get(config.msg)
data=result.get(config.info)
except:
data={config.username:username, config.password:password}
headers = {config.content_type:config.application_json}
token=requests.post(auth_url,data=json.dumps(data),headers=headers)
return Response(token.content,status=st.HTTP_400_BAD_REQUEST)
if message !=config.success:
data={config.username:username, config.password:password}
headers = {config.content_type:config.application_json}
token=requests.post(auth_url,data=json.dumps(data),headers=headers)
return Response(token.content,status=st.HTTP_400_BAD_REQUEST)
elif message ==config.success:
print "@@@@@TRan!for result",message
#To check auth user table for user is exist or not
user_check=crud.get(config.auth_user,[config.email],config.where_email.format(str(data.get(config.email))))
if not user_check:
user = User.objects.create_user(username=username,
email=data.get(config.email),is_staff=True,is_superuser=True,
password=password)
data={ config.username:username,config.password:password}
headers = {config.content_type: config.application_json}
token=requests.post(auth_url,data=json.dumps(data),headers=headers)
token=json.loads(token.text)
return Response(token)
else:
data={config.username:username,config.password:password}
headers = {config.content_type:config.application_json}
token=requests.post(auth_url,data=json.dumps(data),headers=headers)
token=json.loads(token.text)
return Response(token)
def get_near(lat:float,lon:float,rad:float,db: Session = Depends(get_db)):
R = 6373.0
li = []
row = crud.get(db)
lat1 = radians(lat)
lon1 = radians(lon)
given_radii = rad
for i in row:
if i.lat is None or i.lon is None:
continue
lat2 = radians(float(i.lat))
lon2 = radians(float(i.lon))
dlon = lon2 - lon1
dlat = lat2 - lat1
a = sin(dlat / 2.0)**2.0 + cos(lat1) * cos(lat2) * sin(dlon / 2.0)**2.0
c = 2.0 * atan2(sqrt(a), sqrt(1.0 - a))
distance = R * c
if distance <= given_radii:
#print(distance)
li.append(i)
return li
def get_file_data(self, request, files):
l = {}
crud.execute(
"create or replace view file_share as select fs.id,fs.file_id,fsu.user_id,fsg.group_id,fs.can_read,fs.can_write,fs.can_delete from file_manager_share as fs left join file_manager_share_group_ids as fsg on fs.id = fsg.share_id left join file_manager_share_user_ids as fsu on fs.id = fsu.share_id where file_id is not null"
)
file_share_data = crud.get('file_share', "*", '')
map(
lambda x: l.get(x.get('file_id')).get('shared_ids').append(x)
if x.get('file_id') in l else l.update(
{x.get('file_id'): {
'shared_ids': [x]
}}), file_share_data)
map(
lambda (k, v): v.update({
'user_ids':
list(
set(map(lambda fd: fd.get('user_id'), v.get('shared_ids')))
),
'group_ids':
list(
set(map(lambda fd: fd.get('group_id'), v.get('shared_ids'))
))
}), l.iteritems())
tags = map(
lambda f: f.update({
'tags': [
i[0] for i in crud.execute(
"select tag_id from {0} where file_id = {1}".format(
"file_manager_file_tags", f.get('id')))
]
}) if f.get('id') else '', files)
workflow_info = map(
lambda i: i.update(
{'workflow_id': obj.get_workflow_status(i['workflow_id'])})
if i.get('workflow_id') else '', files)
shared_files = map(
lambda f: f.update({'shared_files': l.get(f.get('id'))}), files)
return files
def get():
jsonData = crud.get()
response = jsonify(cars=jsonData)
response.headers.add("Access-Control-Allow-Origin", "*")
return response
#!/usr/bin/env python
import crud
from pprint import pprint
print '-'*80
print 'BEGIN Testing storage.MySQL.crud...'
crud = crud.Crud('store_test')
crud.query('SELECT * FROM session_data')
crud.insert('session_data', [('key1', 'val1', 'str', 'sess1', 1234567890), ('key1', 'val1', 'str', 'sess1', 1234567890), ('key1', 'val1', 'str', 'sess1', 1234567890)])
crud.insert('session_data2', [('key1', 'val1', 'str', 'sess1', 1234567890), ('key1', 'val1', 'str', 'sess1', 1234567890), ('key1', 'val1', 'str', 'sess1', 1234567890)])
pprint(crud.get('session_data', {'session_id2=': "'sess1'", '`key`=': "'key2'"}))
pprint(crud.get('session_data', {'session_id=': "'sess1'", '`key`=': "'key2'"}))
crud.delete('session_data2')
crud.delete('session_data')
crud.insert('session_data', data=[('key2', 'val1', 'str', 'sess1', 1234567890)])
crud.drop_tables()
crud.create_tables()
crud.insert('session_data', data=[('key2', 'val1', 'str', 'sess1', 1234567890)])
crud.update('session_data2', data={'value': 'val3'}, conditions=[{'session_id=': "'sess1'"}, {'utime=':str(1234567890)}])
crud.update('session_data', data={'value': 'val3'}, conditions=[{'session_id=': "'sess1'"}, {'utime=':str(1234567890)}])
print 'END Testing storage.MySQL.crud...'
def get_entity(resource, entity_id):
resource_class = get_resource_class(resource)
return crud.get(resource_class, entity_id)
def generate_log(self, request, param=None, original_data=None, fields=None, ChangeTag=None):
activity = ActivityView()
#print "1=============================>param:",param,"\nreques",request,'\n === fileds',fields
if param is not None:
if fields is None:
table = Log._meta.db_table
name=config.Created
log_data = {
config.created_by_id: request.get(config.user_id), config.created_date: datetime.now(),
config.modified_date: datetime.now(),config.modified_by_id:request.get(config.user_id)}
log_data.update({param.get(config.field):request.get(config.id)})
id = crud.add(table,log_data)
logger.debug(config.Generating_log.format(id))
if id:
if isinstance(id,int):
message=str(param.get(config.label))+" "+str(events.get(config.Created))
logger.debug(config.Create_message.format(message))
activity.generate_activity(request,events.get(config.Created),message,id)
else:
logger.error(config.Log_id_not_found,id)
else:
# print " 2 ====================================================param==>",param,'\n==> reques=>',request,'\n change tag',ChangeTag,'\n====,fileds',fields
updated_value=[]
message_data=[]
table = Log._meta.db_table
if original_data and fields:
#change_value=jd.diff(original_data[0],request)
change_value=jd.diff((original_data),dict(request),syntax=config.symmetric)
updated_value = {key: value for key, value in change_value.items() if fields.get(key)}
if updated_value:
#updated_value = filter(lambda key:key in fields,change_value)
mes={message_data.append(str(param.get(config.label))+' '+str(fields.get(k).get(config.label))+config.has_been_changed_from+str(updated_value.get(k)[0])+" to "+str(updated_value.get(k)[1])) for k in updated_value.keys()}
id=original_data.get(config.id)
else:
logger.debug(config.actvity_update.format(config.Track_fields_not_match))
id=None
if ChangeTag:
if config.Added in ChangeTag.keys():
name=config.Updated
msg=message_data.append(str(ChangeTag.get(config.Added).get(config.field)+" "+str( [j for i, j in enumerate(ChangeTag.get(config.Added).get(config.tag))])+" - "+ ChangeTag.get(config.Added).get(config.action)+" for "+str(param.get(config.label))+" "+request.get(config.name) ))
id=original_data.get(config.id)
if config.Removed in ChangeTag.keys():
msg=message_data.append(str(ChangeTag.get(config.Removed).get(config.field)+" "+str( [j for i, j in enumerate(ChangeTag.get(config.Removed).get(config.tag))])+" - "+ ChangeTag.get(config.Removed).get(config.action)+" From "+str(param.get(config.label))+" "+request.get(config.name) ))
id=original_data.get(config.id)
name=config.Updated
elif param.get(config.label)==config.Workflow:
id=param.get(config.workflow_id)
name=config.Updated
mes={message_data.append(str(param.get(config.label))+" "+config.has_been_changed_from+str(fields[0])+" to "+str(fields[1]))}
message={}
message.update({config.message:message_data})
elif param.get(config.action)==config.share:
id=request.get(param.get(config.field))
name=config.Updated
uname=[]
def get_name(self,table_name,parameters,id):
name=crud.get(table_name,parameters,config.where_id.format(id))
if table_name==config.auth_user:
name=str(name[0].get(parameters[0])+" "+name[0].get(parameters[1])).title()
if table_name==config.auth_group:
name=str(name[0].get(parameters[0])).title()
return name
permission=map(lambda k:fields.get(k) if request.get(k)!=False else None,[i for i in fields.keys()])
if request.get(config.user_ids):
uname=map(lambda id:get_name(self,config.auth_user,[config.first_name,config.last_name],id),request.get(config.user_ids))
mes={message_data.append(str(param.get(config.label))+" "+config.share_user_msg+" "+str(uname)+" "+config.with_key+" "+str([p for p in permission if p != None ])+" "+config.permissions)}
if request.get(config.group_ids):
groups=map(lambda gid:get_name(self,config.auth_group,[config.name],gid),request.get(config.group_ids))
mes={message_data.append(str(param.get(config.label))+" "+config.share_group_msg+" "+str(groups)+" "+config.with_key+" "+str([p for p in permission if p != None ])+" "+config.permissions )}
message={}
message.update({config.message:message_data})
elif param.get(config.label)==config.version:
id=param.get(config.file_id)
name=config.version
#verion_count=crud.execute(crud.fetch_query("activity_log","version_count").format(param.get(config.file_id)))
verion_count=crud.execute("select count(activity_log_log.id)from activity_log_log inner join activity_log_activity on activity_log_log.id=activity_log_activity.log_id where activity_log_activity.name like '%version%' and file_id="+id)
verion_count=verion_count[0][0]
mes={message_data.append(str(param.get(config.label))+" "+str(verion_count+1))}
message={}
message.update({config.message:message_data})
if id:
log=crud.get(self.table,config.all,config.where +param.get(config.field)+'='+str(id))
log_id=log[0].get(config.id)
if isinstance(log_id,int):
for msg in message_data:
activity.generate_activity(request,events.get(name),msg,log_id)
else:
logger.debug(config.Log_id_not_found,log_id)
else:
logger.debug(config.Data_before_update_not_awailable)
else:
Response(config.Parametter_missing)
def create(self, request):
"""
<b>Author: </b> Manickam \n
Service to create a new Directory. Send payload based on Example value.
\n
"""
try:
uam_func_sync(request, c.strUAMLink, c.strAppName, c.strAppClient,
"File Manager ", "Create",
request.session.session_key,
request.META.get('HTTP_X_FORWARDED_FOR'))
except Exception as e:
logger.info(e)
user_name = request.user.first_name + request.user.last_name
user_id = request.user.id
# directory_data = request.data
# tags = directory_data.pop(c.tags)
# response = crud.add(self.table, directory_data)
# return Response(response)
serializer = DirectorySerializer(data=request.data)
if serializer.is_valid():
directory_data = request.data
tag = [
istags for istags in directory_data.keys() if istags == c.tags
]
if istags:
tags = directory_data.pop("tags")
directory_data.update({
'created_date':
datetime.now(),
'modified_date':
datetime.now(),
'created_by_id':
directory_data.get('owner_id'),
'modified_by_id':
directory_data.get('owner_id')
})
#tags = directory_data.pop(c.tags)
# directory_data.update({c.created_date:datetime.now(),c.modified_date:datetime.now(),c.created_by_id:directory_data.get(c.owner_id),c.modified_by_id:directory_data.get(c.owner_id)})
directory_id = crud.add(self.table, directory_data)
if tags:
for tag in tags:
directory_tag_data = {
c.directory_id: directory_id,
c.tag_id: tag
}
crud.add(c.tag_dir_rel, directory_tag_data)
param = {
'field': 'directory_id',
'label': 'Directory',
'user_name': user_name
}
# self.add_log(act_log_data=serializer.data)
act_log_data = request.data
act_log_data.update({'id': directory_id, 'user_id': user_id})
log_view = LogView()
log_view.generate_log(act_log_data, param)
# return Response(directory_id)
# act_log_data=request.data
# act_log_data.update({'id':directory_id})
# log_view = LogView()
# log_view.generate_log(act_log_data,param)e
response = crud.get(self.table, c.all,
c.where_id_param.format(directory_id))
return Response(response[0])
else:
return Response(serializer.errors)
def update(self, request, pk=None):
try:
uam_func_sync(request, c.strUAMLink, c.strAppName, c.strAppClient,
"File Manager ", "Update",
request.session.session_key,
request.META.get('HTTP_X_FORWARDED_FOR'))
except Exception as e:
logger.info(e)
user_name = request.user.first_name + request.user.last_name
try:
# request = dict(request.data)
param = {
'field': 'directory_id',
'label': 'Directory',
'user_name': user_name
}
# print "\n\n\n@@@@@@data @@",request.data
# payload = request.data
# #payload=serializer.data
# print "original data:%%%%%%%%,",payload
original_data = crud.get(self.table, c.all,
'where id=' + str(pk))[0]
# tags = crud.execute("select tag_id from file_manager_directory_tags where directory_id={}".format(pk))
# shared_ids = crud.execute("select id from file_manager_share where directory_id={}".format(pk))
# original_data.update({c.tags:list(tags and zip(*tags)[0]), 'shared_ids':list(shared_ids and zip(*shared_ids)[0])})
# logger.debug("Files:: get_parent_dirs: Parent Files{}".format(original_data))
# #try:
# payload.update({"id":pk})
# tags = payload.pop(c.tags)
# file_ids=payload.pop("file_ids")
# parent_id=payload.pop("parent_id")
# shared_ids = payload.pop("shared_ids")
# sub_directories=payload.pop("sub_directories")
# workflow_id=payload.pop(c.workflow_id)
# response = crud.update(self.table,payload )
# print "Response",response
param = {
'field': 'directory_id',
'label': 'Directory',
'user_name': user_name
}
original_data = crud.get(self.table, c.all,
'where id=' + str(pk))[0]
dir_obj = Directory.objects.get(id=pk)
serializer = DirectorySerializer(dir_obj, data=request.data)
if serializer.is_valid():
tag_details = self.tag_change(pk, request.data, "directory")
new_tag_ids = {}
old_tag_ids = {}
added_tag = tag_details.get("added_tag")
deleted_tag = tag_details.get("deleted_tag")
new_tag_ids.update(tag_details.get("new_tag_ids"))
old_tag_ids.update(tag_details.get("old_tag_ids"))
directory_update = request.data
for i in directory_update.keys():
if i in [
c.tags, 'parent_id', 'workflow_id', 'shared_dirs',
'file_ids', 'sub_directories'
]:
if i == c.tags:
update_tag = directory_update.pop(i)
else:
directory_update.pop(i)
directory_id = crud.update(self.table, directory_update)
if added_tag:
for tag in added_tag:
directory_tag_data = {
c.directory_id: directory_id,
"tag_id": new_tag_ids.get(tag)
}
crud.add(c.tag_dir_rel, directory_tag_data)
if deleted_tag:
for tag in deleted_tag:
try:
crud.execute(
"delete from file_manager_directory_tags where tag_id={} and directory_id={}"
.format(old_tag_ids.get(tag), pk), True)
except Exception as err:
return Response(err)
logger.debug("Files:: Serializer{}".format(request.data))
log_view = LogView()
original_data1 = {}
map(
lambda x: original_data1.update(
{str(x): original_data.get(x)}), original_data)
# original_data1.update({c.tags:old_tag})
current_data = request.data
current_data.update({'user_id': request.user.id})
ChangeTag = {}
if added_tag:
ChangeTag.update({
"Added": {
c.field: "Tag",
"tag": [Tag for Tag in added_tag],
"action": "Added"
}
})
if deleted_tag:
ChangeTag.update({
"Removed": {
c.field: "Tag",
"tag": [Tag for Tag in deleted_tag],
"action": "Removed"
}
})
log_view.generate_log(
current_data,
param,
original_data1,
self.track_fields,
ChangeTag,
)
return Response(
crud.get(self.table, c.all,
c.where_id_param.format(directory_id)))
else:
logger.debug("Files:: Serializer{}".format(serializer.errors))
return Response(serializer.errors)
except Exception as err:
return Response(err)
def update(self, request, pk=None):
user_name = request.user.first_name + request.user.last_name
track_fields = {
c.name: {
c.field: c.name,
c.label: "Name"
},
c.tags: {
c.field: c.tags,
c.label: "Tags"
}
}
param = {'field': 'file_id', 'label': 'File', 'user_name': user_name}
original_data = crud.get(self.table, c.all, 'where id=' + pk)[0]
logger.debug(
"Files:: get_parent_dirs: Parent Files{}".format(original_data))
dir_obj = File.objects.get(id=pk)
serializer = FileSerializer(dir_obj, data=request.data)
if serializer.is_valid():
dir_view = DirectoryView()
tag_details = dir_view.tag_change(pk, request.data, "file")
new_tag_ids = {}
old_tag_ids = {}
added_tag = tag_details.get("added_tag")
new_tag = tag_details.get("new_tag")
deleted_tag = tag_details.get("deleted_tag")
new_tag_ids.update(tag_details.get("new_tag_ids"))
old_tag_ids.update(tag_details.get("old_tag_ids"))
file_update = request.data
update_tag = file_update.pop(c.tags)
serializer.save()
file_id = pk
# if added_tag:
# for tag in added_tag:
# file_tag_data = {"file_id": file_id,
# "tag_id": new_tag_ids.get(tag)}
# crud.add('file_manager_file_tags', file_tag_data)
if deleted_tag:
for tag in deleted_tag:
try:
crud.execute(
"delete from file_manager_file_tags where tag_id={} and file_id={}"
.format(old_tag_ids.get(tag), pk), True)
except Exception as err:
return Response(err)
log_view = LogView()
original_data1 = {}
map(
lambda x: original_data1.update({str(x): original_data.get(x)}
), original_data)
ChangeTag = {}
if added_tag:
ChangeTag.update({
"Added": {
c.field: "Tag",
"tag": [Tag for Tag in added_tag],
"action": "Added"
}
})
if deleted_tag:
ChangeTag.update({
"Removed": {
c.field: "Tag",
"tag": [Tag for Tag in deleted_tag],
"action": "Removed"
}
})
request_data = request.data
request_data.update({'user_id': request.user.id})
log_view.generate_log(request.data, param, original_data1,
track_fields, ChangeTag)
# settings.connection_es.update(index='dms_test',doc_type='post',body={'doc':{'name':file.name,'type':'File','content_type':file.content_type,'owner_id':request.user.id,'tags':''}})
return Response(serializer.data)
else:
return Response(serializer.errors)
def get_templates(self, request, *args, **kwargs):
template_res = crud.get(self.table, "*", "WHERE is_template IS true")
return Response(template_res)
