def edit_branding_update(request):
logger = logging.getLogger(__name__)
form = forms.AccountBrandingForm(request.POST)
if form.is_valid():
urls = {}
account = request.auth_manager.get_account()
form_fields_keys = form.fields.keys()
form_fields_keys.remove('account_favicon')
form_fields_keys.remove('account_logo')
for field_key in form_fields_keys:
key = field_key.replace('_', '.')
value = form.cleaned_data[field_key]
account.set_preference(key, value)
accountid = str(request.auth_manager.account_id)
if request.FILES.has_key('account_favicon'):
data = request.FILES['account_favicon']
keyname = 'favicon'
active_datastore.upload(settings.AWS_CDN_BUCKET_NAME, keyname, data, account_id=accountid)
value = '{}/{}/{}'.format(get_domain_with_protocol('cdn'), accountid, keyname)
account.set_preference('account.favicon', value)
urls['id_account_favicon'] = value
if request.FILES.has_key('account_logo'):
data = request.FILES['account_logo']
keyname = 'logo'
active_datastore.upload(settings.AWS_CDN_BUCKET_NAME, keyname, data, account_id=accountid)
value = '{}/{}/{}'.format(get_domain_with_protocol('cdn'), accountid, keyname)
account.set_preference('account.logo', value)
urls['id_account_logo'] = value
is_ie = False
if request.META.has_key('HTTP_USER_AGENT'):
user_agent = request.META['HTTP_USER_AGENT']
pattern = "msie [1-9]\."
prog = re.compile(pattern, re.IGNORECASE)
match = prog.search(user_agent)
if match:
is_ie = True
if is_ie:
return HttpResponse(json.dumps({'status': 'ok', 'messages': [ugettext('APP-SETTINGS-SAVE-OK-TEXT')], 'urls': urls}), content_type='text/plain')
else:
return HttpResponse(json.dumps({'status': 'ok', 'messages': [ugettext('APP-SETTINGS-SAVE-OK-TEXT')], 'urls': urls}), content_type='application/json')
else:
errors = generate_ajax_form_errors(form)
response = {'status': 'error', 'messages': errors}
return HttpResponse(json.dumps(response), content_type='application/json', status=400)
def forgot_password(request):
if request.method == "GET":
return render_to_response("accounts/forgotPassword.html", locals())
if request.method == "POST":
ok = False
try:
user_identification = request.REQUEST["identification"]
except:
raise Http404
try:
user = User.objects.get(Q(nick=user_identification) | Q(email=user_identification))
except:
user = ""
if user:
uuid = uuid4()
pass_ticket = UserPassTickets.objects.create(uuid=uuid, user_id=user.id, type="PASS")
url = get_domain_with_protocol("workspace") + "/recovery?id=" + str(uuid)
DjangoMailService().send_forgot_password_mail(user, url)
message = ugettext("FORGOT-ACTIVATION-EMAIL")
ok = True
else:
message = ugettext("FORGOT-USER-NOFOUND")
return HttpResponse(
'{"p_message":"' + message + '", "ok" :"' + str(ok) + '" }', content_type="application/json"
)
def invoke_chart(query):
content_type = settings.CONTENT_TYPES.get("json")
try:
engine_domain = get_domain_with_protocol('engine')
url = engine_domain + settings.END_POINT_CHART_SERVLET
memcached = settings.MEMCACHED_ENGINE_END_POINT
if memcached:
engine_cache = memcache.Client(memcached, debug=0)
if engine_cache:
key = str(hash(frozenset(sorted(query.items()))))
value = engine_cache.get(key)
if value is None:
value, content_type = _request(query, url)
engine_cache.set(key, value, settings.MEMCACHED_DEFAULT_TTL)
return value, content_type
else:
return value, content_type
else:
logger = logging.getLogger(__name__)
logger.debug('No memcached client could be created. Chart will be retrieved from engine.')
value, content_type = _request(query, url)
if not value:
value = '{"error":"Sin valor para %s en URL: %s"}' % (query, url)
content_type = "json"
return value, content_type
except Exception, e:
logger = logging.getLogger(__name__)
logger.debug(e)
def forgot_password(request):
if request.method == 'GET':
return render_to_response('accounts/forgotPassword.html', locals())
if request.method == 'POST':
ok = False
try:
user_identification = request.REQUEST['identification']
except:
raise Http404
try:
user = User.objects.get(
Q(nick=user_identification) | Q(email=user_identification))
except:
user = ''
if user:
uuid = uuid4()
pass_ticket = UserPassTickets.objects.create(uuid=uuid,
user=user,
type='PASS')
url = get_domain_with_protocol(
'workspace') + "/recovery?id=" + str(uuid)
DjangoMailService().send_forgot_password_mail(user, url)
message = ugettext('FORGOT-ACTIVATION-EMAIL')
ok = True
else:
message = ugettext('FORGOT-USER-NOFOUND')
return HttpResponse('{"p_message":"' + message + '", "ok" :"' +
str(ok) + '" }',
content_type='application/json')
def upload(request):
value = ''
for filename, file in request.FILES.iteritems():
valuelist = request.FILES.getlist(filename)
for val in valuelist:
data = val
name = data.name
accountid = str(request.auth_manager.account_id)
keyname = "%s/%s" % (accountid, name)
active_datastore.upload(settings.AWS_CDN_BUCKET_NAME, name, data,
str(request.auth_manager.account_id))
value = get_domain_with_protocol('cdn') + '/' + keyname
if request.FILES is None:
response_data = [{"error": 'Must have files attached!'}]
return HttpResponse(json.dumps(response_data))
if request.method == 'POST':
is_ie = False
if request.META.has_key('HTTP_USER_AGENT'):
user_agent = request.META['HTTP_USER_AGENT']
pattern = "msie [1-9]\."
prog = re.compile(pattern, re.IGNORECASE)
match = prog.search(user_agent)
if match:
is_ie = True
if is_ie:
return HttpResponse(json.dumps({"url": value}),
content_type='text/plain')
else:
return HttpResponse(json.dumps({"url": value}),
content_type='application/json')
def build_data_source(self):
dataset_revision_id=self.args.get('dataset_revision_id')
table_id=self.args.get('table_id', 'table0')
import urllib
from bs4 import BeautifulSoup
from core.http import get_domain_with_protocol
params = urllib.urlencode({'pId': dataset_revision_id, 'pLimit': 50})
url = get_domain_with_protocol('engine') + '/AgileOfficeServer/DataSourceLoaderServlet?' + params
response_body = urllib.urlopen(url).read()
soup = BeautifulSoup(response_body)
table = soup.find(attrs={'tableid': table_id})
try:
number_of_columns = len(table.findAll('tr')[0].findAll())
except:
import logging
logger = logging.getLogger(__name__)
logger.error("get_impl_details ERROR --> %s" % response_body)
raise
impl_details_xml = '<dataSource><DataStructure><Field id="%s"><type></type><format><languaje></languaje><country></country><style></style></format><Table>' % table_id
for i in range(number_of_columns):
impl_details_xml = impl_details_xml + '<Field id="column%d"><alias></alias><type></type><format><languaje></languaje><country></country><style></style></format></Field>' % i
impl_details_xml = impl_details_xml + '</Table></Field></DataStructure></dataSource>'
return impl_details_xml
def upload(request):
value = ''
for filename, file in request.FILES.iteritems():
valuelist = request.FILES.getlist(filename)
for val in valuelist:
data = val
name = data.name
accountid = str(request.auth_manager.account_id)
keyname = "%s/%s" %(accountid[::-1], name)
active_datastore.upload(settings.AWS_CDN_BUCKET_NAME, name, data, str(request.auth_manager.account_id))
value = get_domain_with_protocol('cdn') + '/' + keyname
if request.FILES is None:
response_data = [{"error": 'Must have files attached!'}]
return HttpResponse(json.dumps(response_data))
if request.method == 'POST':
is_ie = False
if request.META.has_key('HTTP_USER_AGENT'):
user_agent = request.META['HTTP_USER_AGENT']
pattern = "msie [1-9]\."
prog = re.compile(pattern, re.IGNORECASE)
match = prog.search(user_agent)
if match:
is_ie = True
if is_ie:
return HttpResponse(json.dumps({"url": value}), content_type='text/plain')
else:
return HttpResponse(json.dumps({"url": value}), content_type='application/json')
def preview_chart(query):
content_type = settings.CONTENT_TYPES.get("json")
try:
engine_domain = get_domain_with_protocol('engine')
url = engine_domain + settings.END_POINT_CHART_PREVIEWER_SERVLET
value, content_type = _request(query, url)
return value, content_type
except Exception, e:
logger = logging.getLogger(__name__)
logger.debug(e)
raise e
def invoke(query, output=None):
if not output:
output = 'json'
query['pOutput'] = output.upper()
content_type = settings.CONTENT_TYPES.get(output)
try:
engine_domain = get_domain_with_protocol('engine')
url = engine_domain + settings.END_POINT_SERVLET
memcached = settings.MEMCACHED_ENGINE_END_POINT
if memcached:
engine_cache = memcache.Client(memcached, debug=0)
if engine_cache:
key = str(hash(frozenset(sorted(query.items()))))
value = engine_cache.get(key)
if value is None:
value, content_type = _request(query, url)
engine_cache.set(key, value, settings.MEMCACHED_DEFAULT_TTL)
return value, content_type
else:
return value, content_type
else:
logger = logging.getLogger(__name__)
logger.debug('No memcached client could be created. Dataview will be retrieved from engine.')
return _request(query, url)
except Exception, e:
""" TOO much logging from here
logger = logging.getLogger(__name__)
logger.debug('{0}. Dataview will be retrieved from redis '.format(str(e)))
"""
if output == 'json':
if 'pFilter0' not in query:
dataviews_cache = Cache(db=settings.CACHE_DATABASES['dataviews'])
key = str(query.get('pId'))
params = [ query[arg].decode('utf-8') for arg in sorted(query.keys()) if arg.startswith('pArgument')]
if params:
key += u'::' + u':'.join(params)
return dataviews_cache.get(key), content_type
return None, content_type
def process_request(self, request):
domain = get_domain_by_request(request)
request.bucket_name = settings.AWS_BUCKET_NAME
try:
account = Account.get_by_domain(domain)
except Account.DoesNotExist:
logger = logging.getLogger(__name__)
logger.error('The account do not exists: %s' % domain)
return HttpResponseForbidden('')
request.account = account
preferences = account.get_preferences()
preferences.load_all()
preferences['account_id'] = account.id
request.preferences = preferences
bucket_name = preferences['account_bucket_name']
if bucket_name:
request.bucket_name = bucket_name
is_signin = False #Deprecado
is_login = False #Deprecado
is_activate = False #Deprecado
is_jsi18n = request.path.startswith('/jsi18n')
language = request.preferences['account_language']
if language:
request.session['django_language'] = language
request.auth_manager.language = language
# TODO: Esto debería ir en una url y hacer el redirect
if settings.DOMAINS['microsites'] == domain:
if request.META.get('REQUEST_URI') == '/':
return redirect(
get_domain_with_protocol('microsites') + "/home")
# hacemos que el User sea un AccountAnonymousUser
# lo creamos con el account y el lenguaje que tenga el account_language
request.user = AccountAnonymousUser(request.account,
preferences['account_language'])
return None
def process_request(self, request):
domain = get_domain_by_request(request)
request.bucket_name = settings.AWS_BUCKET_NAME
try:
# check for develop domains
if settings.DOMAINS['microsites'].split(":")[0] != domain.split(":")[0]:
account = Account.objects.get_by_domain(domain)
else:
# use default account if exists
account = Account.objects.get(pk=1)
except Account.DoesNotExist:
logger = logging.getLogger(__name__)
logger.error('The account do not exists: %s' % domain)
raise AccountDoesNotExist
request.account = account
preferences = account.get_preferences()
preferences.load_all()
preferences['account_id'] = account.id
request.preferences = preferences
bucket_name = preferences['account_bucket_name']
if bucket_name:
request.bucket_name = bucket_name
is_signin = False #Deprecado
is_login = False #Deprecado
is_activate = False #Deprecado
is_jsi18n = request.path.startswith('/jsi18n')
language = request.preferences['account_language']
if language:
request.session['django_language'] = language
request.auth_manager.language = language
if settings.DOMAINS['microsites'] == domain:
if request.META.get('REQUEST_URI') == '/':
return redirect(get_domain_with_protocol('microsites') + "/home")
return None
def process_request(self, request):
domain = get_domain_by_request(request)
request.bucket_name = settings.AWS_BUCKET_NAME
try:
account = Account.get_by_domain(domain)
except Account.DoesNotExist:
logger = logging.getLogger(__name__)
logger.error('The account do not exists: %s' % domain)
return HttpResponseForbidden('')
request.account = account
preferences = account.get_preferences()
preferences.load_all()
preferences['account_id'] = account.id
request.preferences = preferences
bucket_name = preferences['account_bucket_name']
if bucket_name:
request.bucket_name = bucket_name
is_signin = False #Deprecado
is_login = False #Deprecado
is_activate = False #Deprecado
is_jsi18n = request.path.startswith('/jsi18n')
language = request.preferences['account_language']
if language:
request.session['django_language'] = language
request.auth_manager.language = language
# TODO: Esto debería ir en una url y hacer el redirect
if settings.DOMAINS['microsites'] == domain:
if request.META.get('REQUEST_URI') == '/':
return redirect(get_domain_with_protocol('microsites') + "/home")
# hacemos que el User sea un AccountAnonymousUser
# lo creamos con el account y el lenguaje que tenga el account_language
request.user = AccountAnonymousUser(request.account, preferences['account_language'])
return None
def process_request(self, request):
domain = get_domain_by_request(request)
request.bucket_name = settings.AWS_BUCKET_NAME
try:
account = Account.get_by_domain(domain)
except Account.DoesNotExist:
logger = logging.getLogger(__name__)
logger.error('The account do not exists: %s' % domain)
raise AccountDoesNotExist
request.account = account
preferences = account.get_preferences()
preferences.load_all()
preferences['account_id'] = account.id
request.preferences = preferences
bucket_name = preferences['account_bucket_name']
if bucket_name:
request.bucket_name = bucket_name
is_signin = False #Deprecado
is_login = False #Deprecado
is_activate = False #Deprecado
is_jsi18n = request.path.startswith('/jsi18n')
language = request.preferences['account_language']
if language:
request.session['django_language'] = language
request.auth_manager.language = language
if settings.DOMAINS['microsites'] == domain:
if request.META.get('REQUEST_URI') == '/':
return redirect(get_domain_with_protocol('microsites') + "/home")
return None
account = request.account
is_free = False
except AttributeError:
try:
account_id = DataStream.objects.values('user__account_id').get(pk=id)['user__account_id']
account = Account.objects.get(pk=account_id)
is_free = True
except (DataStream.DoesNotExist, Account.DoesNotExist), e:
logger.debug('Datstream or account doesn\'t exists [%s|%s]=%s' % (str(id), str(account_id), repr(e)))
raise Http404
preferences = request.preferences
if not is_free:
base_uri = 'http://' + preferences['account_domain']
else:
base_uri = get_domain_with_protocol('microsites')
datastreamrevision_id = DataStreamRevision.objects.get_last_published_id(id)
datastream = DataStreamDBDAO().get(preferences['account_language'], datastream_revision_id=datastreamrevision_id)
impl_type_nice = set_dataset_impl_type_nice(datastream['impl_type']).replace('/',' ')
""" #TODO this must be at middleware
# verify if this account is the owner of this viz
dats = DataStream.objects.get(pk=id)
if account.id != dats.user.account.id:
logger.debug('Can\'t show. Not owner [%s|%s]=%s' % (id, str(account.id), str(dats.user.account.id), "Not owner"))
raise Http404
"""
url_query = urllib.urlencode(RequestProcessor(request).get_arguments(datastream['parameters']))
def _get_url(self):
return get_domain_with_protocol(self.app) + self.endpoint
def _get_url(self):
return get_domain_with_protocol(self.app, engine=True) + self.endpoint
def _get_url(self):
return get_domain_with_protocol('engine') + self.endpoint
def edit_branding_update(request):
logger = logging.getLogger(__name__)
form = forms.AccountBrandingForm(request.POST)
if form.is_valid():
urls = {}
account = request.auth_manager.get_account()
form_fields_keys = form.fields.keys()
form_fields_keys.remove('account_favicon')
form_fields_keys.remove('account_logo')
for field_key in form_fields_keys:
key = field_key.replace('_', '.')
value = form.cleaned_data[field_key]
account.set_preference(key, value)
accountid = str(request.auth_manager.account_id)
if request.FILES.has_key('account_favicon'):
data = request.FILES['account_favicon']
keyname = 'favicon'
active_datastore.upload(settings.AWS_CDN_BUCKET_NAME,
keyname,
data,
account_id=accountid)
value = '{}/{}/{}'.format(get_domain_with_protocol('cdn'),
accountid, keyname)
account.set_preference('account.favicon', value)
urls['id_account_favicon'] = value
if request.FILES.has_key('account_logo'):
data = request.FILES['account_logo']
keyname = 'logo'
active_datastore.upload(settings.AWS_CDN_BUCKET_NAME,
keyname,
data,
account_id=accountid)
value = '{}/{}/{}'.format(get_domain_with_protocol('cdn'),
accountid, keyname)
account.set_preference('account.logo', value)
urls['id_account_logo'] = value
is_ie = False
if request.META.has_key('HTTP_USER_AGENT'):
user_agent = request.META['HTTP_USER_AGENT']
pattern = "msie [1-9]\."
prog = re.compile(pattern, re.IGNORECASE)
match = prog.search(user_agent)
if match:
is_ie = True
if is_ie:
return HttpResponse(json.dumps({
'status':
'ok',
'messages': [ugettext('APP-SETTINGS-SAVE-OK-TEXT')],
'urls':
urls
}),
content_type='text/plain')
else:
return HttpResponse(json.dumps({
'status':
'ok',
'messages': [ugettext('APP-SETTINGS-SAVE-OK-TEXT')],
'urls':
urls
}),
content_type='application/json')
else:
errors = generate_ajax_form_errors(form)
response = {'status': 'error', 'messages': errors}
return HttpResponse(json.dumps(response),
content_type='application/json',
status=400)
def preview(query):
engine_domain = get_domain_with_protocol('engine')
url = engine_domain + settings.END_POINT_PREVIEWER_SERVLET
return _request(query, url, method='POST')
def load(query):
engine_domain = get_domain_with_protocol('engine')
url = engine_domain + settings.END_POINT_LOADER_SERVLET
return _request(query, url)
def _get_url(self):
return get_domain_with_protocol(self.app) + self.endpoint
