def post(self, request, *args, **kwargs):
user=request.user
pid=request.GET.get('project',-1)
fname=EncodeProjectConfig(pid)
data={}
try:
project = Project.objects.get(pk=pid,user=user)
except:
response = HttpResponse('Error: Invalid project')
response.status_code = 404
print('get project error')
return response
try:
prj_json=json_gdml.ProjectJSON(fname)
except:
response = HttpResponse('Error: Invalid config file')
response.status_code = 404
print('generate config file error')
return response
#get config
try:
instance=Instance.objects.filter(name=prj_json.instance)[0]
item=Item.objects.filter(pk=instance.item.id)[0]
except:
print('get instance and item info error, config store item and instance please!')
return handler404(request)
job=None
order=None
#check if exist job which is not executed and the order is not paied
jobs=Job.objects.filter(user=user,project=project,status='UNDO').order_by('-create_time')
if len(jobs) >0:
job=jobs[0]
if job is None:
try:
order=Order.objects.create(user=user)
job=Job.objects.create(user=user,project=project,order=order,instance=instance)
except Exception as e:
print('create job and order error:', repr(e))
return handler404(request)
else:
orders=Order.objects.filter(pk=job.order.id,user=user,paied=False).order_by('-create_time')
if len(orders) >0:
order=orders[0]
#no availiable order, new order and job
if order is None:
try:
order=Order.objects.create(user=user)
job=Job.objects.create(user=user,project=project,order=order,instance=instance)
except Exception as e:
print('create job and order error:', repr(e))
return handler404(request)
order.ClearItem()
order.AddItem(item.id,item.price, int(prj_json.nodes), float(prj_json.run_time))
order.save()
job.order=order
job.instance=instance
job.nodes=prj_json.nodes
job.times=prj_json.run_time
job.save()
print('create job with instance %s, price %s, nodes %s, time %s' %
(instance.type,item.price,job.nodes,job.times))
if MakeJobConfig(project.id,job.id)!=True:
print('make job config error')
return handler404(request)
try:
job_script=execute_job.JobScript(job.id,instance,job.nodes,job.times*60)
except:
print('create job script error')
return handler404(request)
job_serializer = JobSerializer(job)
order.charge=round(order.charge,2)
order_serializer = OrderSerializer(order)
order_data=order_serializer.data
names=[item.name]
order_data['names']=names
data={'success':True,'job':job_serializer.data,'order':order_data}
return JsonResponse(data, content_type='application/json',safe=False)
def get(self, req):
heroes = list(Hero.objects.values().all())
return JsonResponse({'status': 'OK', 'heroes': heroes})
def Status_update(request, pk):
data = dict()
estatus = get_object_or_404(Actividades, pk=pk)
if request.method == 'POST':
form = StatusForm(request.POST, instance=estatus)
fecha = ''
for i in request.POST:
print(request.POST)
if i == 'fecha_submit':
estatus_id = get_object_or_404(Status, status="Por Realizar")
fecha = request.POST['fecha_submit']
hora = request.POST['hora']
print('obtengo la fecha a actualizar ', fecha)
if fecha:
#Nuevo registro
if estatus.entrenamiento:
entrenamiento = estatus.entrenamiento
else:
entrenamiento = None
estatus.suspended = True
estatus.save()
actividad_new = Actividades(nombre=estatus.nombre,
descripcion=estatus.descripcion,
fecha=fecha,
hora=hora,
lugar=estatus.lugar,
persona=estatus.persona,
status=estatus_id,
tipo=estatus.tipo,
entrenamiento=entrenamiento)
actividad_new.save()
data['id'] = actividad_new.pk
status_p = form.save(commit=False)
data['create'] = True
data['lugar'] = estatus.lugar
data['descripcion'] = estatus.descripcion
data['title'] = estatus.nombre
data['color'] = "#00B0F0"
data['start'] = str(fecha) + "T" + str(hora)
data['estatus'] = estatus_id.status
data['form_is_valid'] = True
notificacions(
user=request.user,
contenido="Actividad titulada: <strong>" + estatus.nombre +
"</strong> actualizada a una nueva fecha: <p style='color:green;display: contents;'><strong>"
+ str(estatus.fecha) + "</strong></p>",
url="")
else:
if form.is_valid():
form.save()
if estatus.status.status == 'Suspendida':
color = "#ffc100"
print("Suspendida")
if estatus.status.status == 'Realizada':
color = "green"
print(color)
if estatus.status.status == 'Por Realizar':
color = "#00B0F0"
if estatus.status.status == 'No Realizada':
color = "red"
data['form_is_valid'] = True
data['color'] = color
notificacions(
user=request.user,
contenido="Actividad titulada: <strong>" + estatus.nombre +
"</strong> actualizada a: <p style='color:" + color +
";display: contents;'><strong>" + estatus.status.status +
"</strong></p>",
url="")
data['estatus'] = estatus.status.status
else:
form = StatusForm(instance=estatus)
context = {'form': form, 'actividad': estatus}
data['html_form'] = render_to_string('actividades/update.html',
context,
request=request)
return JsonResponse(data)
def update(self, request, *args, **kwagrs):
res = self.update_apps(request)
if isinstance(res, str):
return JsonResponse({'msg': res, "code": 500, 'data': []})
return JsonResponse({'msg': "修改成功", "code": 200, 'data': []})
def user_sign(request):
"""
发布会签到
:param request:
:return:
"""
if request.method == "POST":
# # 获取前端以form表单方式传的参数
# id = request.POST.get("id", "")
# phone = request.POST.get("phone", "")
# 获取前端以json方式传的参数
sign_dict = json.loads(request.body)
try:
id = sign_dict["id"]
phone = sign_dict["phone"]
except KeyError:
return JsonResponse({"status": 500, "message": "字段不能为空"})
# 对各个字段进行空字符串判断，并返回给前台
if id == "" or phone == "":
return JsonResponse({"status": 101, "message": "请求参数为空"})
if type(id) != int:
return JsonResponse({"status": 102, "message": "发布会id参数类型有误"})
if len(phone) != 11:
# print(len(phone))
return JsonResponse({"status": 103, "message": "手机号长度有误"})
# 获取发布会id，并判断id是否存在，如果不存在，则返回
try:
result = Event.objects.get(id=id)
except Event.DoesNotExist:
return JsonResponse({"status": 104, "message": "发布会id不存在"})
# 判断发布会status状态值，如果是False，则代表发布会未开启，无法签到
if result.status is False:
return JsonResponse({"status": 105, "message": "发布会未开启，不能签到"})
# 获取发布会时间，并转换成YYY-MM-DD HH:MM:SS格式
event_time = result.start_time # 发布会时间
timeArray = time.strptime(str(event_time), "%Y-%m-%d %H:%M:%S")
e_time = int(time.mktime(timeArray))
# 获取当前时间
now_time = str(time.time()) # 当前时间
ntime = now_time.split(".")[0]
n_time = int(ntime)
# 拿当前时间与发布会时间进行比较，如果当前时间大于等于发布会时间，则返回异常
if n_time >= e_time:
return JsonResponse({'status': 106, "message": "发布会已开始，无法签到"})
# 获取用户手机号
result = Guest.objects.filter(phone=phone)
# 判断入参的手机号是否存在数据库中
if not result:
return JsonResponse({'status': 107, "message": "签到手机号不存在"})
else:
for res in result:
if res.event_id == int(id):
break
else:
return JsonResponse({'status': 108, 'message': '用户没有参加本场发布会'})
result = Guest.objects.get(event_id=id, phone=phone)
# 判断用户是否已签到
if result.sign is True:
return JsonResponse({'status': 109, 'message': '用户已签到，请勿重复签到'})
# 如果未签到，则执行签到动作，并返回成功
else:
result.sign = True
result.save()
return JsonResponse({'status': 200, 'message': '用户签到成功'})
else:
return JsonResponse({"status": 100, "message": "请求方式有误"})
def create(request, branch_id, is_file, layer_div):
if request.user.profile.auth >= 3:
branch_list = Branch.objects.all().filter(
pk=request.user.profile.branch)
else:
branch_list = Branch.objects.all().order_by('-branch_name')
branch = Branch.objects.get(pk=branch_id)
guide_list = Guide.objects.all().filter(branch=branch_id).order_by('-id')
course_list = Course.objects.all().filter(branch=branch_id).order_by('-id')
layer01 = Layer.objects.filter(branch=branch_id, div=1).last()
layer01Count = Layer.objects.filter(branch=branch_id, div=1).count()
layer02 = Layer.objects.filter(branch=branch_id, div=2).last()
layer02Count = Layer.objects.filter(branch=branch_id, div=2).count()
layer03 = Layer.objects.filter(branch=branch_id, div=3).last()
layer03Count = Layer.objects.filter(branch=branch_id, div=3).count()
layer04 = Layer.objects.filter(branch=branch_id, div=4).last()
layer04Count = Layer.objects.filter(branch=branch_id, div=4).count()
layer05 = Layer.objects.filter(branch=branch_id, div=5).last()
layer05Count = Layer.objects.filter(branch=branch_id, div=5).count()
if request.method == 'POST':
if is_file == '1':
guide_form = GuideForm(request.POST, request.FILES)
if guide_form.is_valid():
guide = guide_form.save(commit=False)
guide.branch_id = branch_id
guide.user = request.user.username
guide = guide_form.save()
data = {
'is_valid': True,
'name': guide.file.name,
'url': guide.file.url,
'branch_id': branch_id
}
# return redirect(reverse('create_main', kwargs={'branch_id': branch_id, 'is_file': is_file}))
else:
data = {'is_valid': False}
return JsonResponse(data)
elif is_file == '2':
course_form = CourseForm(request.POST, request.FILES)
if course_form.is_valid():
course = course_form.save(commit=False)
course.branch_id = branch_id
course.user = request.user.username
course = course_form.save()
data = {
'is_valid': True,
'name': course.file.name,
'url': course.file.url,
'branch_id': branch_id
}
else:
data = {'is_valid': False}
return JsonResponse(data)
elif is_file == '3':
layer_form = LayerForm(request.POST, request.FILES)
if layer_form.is_valid():
layer = layer_form.save(commit=False)
layer.branch_id = branch_id
layer.div = layer_div
layer.type = 1
layer.user = request.user.username
layer = layer_form.save()
layer_id = Layer.objects.filter(
branch=branch_id, div=layer_div).values('id').last()
data = {
'is_valid': True,
'name': layer.file.name,
'url': layer.file.url,
'branch_id': branch_id,
'layer_id': layer_id,
'layer_div': layer_div
}
else:
data = {'is_valid': False}
return JsonResponse(data)
else:
form = LayerForm()
return render(
request, 'main_create.html', {
'form': form,
'branch_id': branch_id,
'branch_name': branch.branch_name,
'branch': branch_list,
'guide': guide_list,
'course': course_list,
'layer01': layer01,
'layer02': layer02,
'layer03': layer03,
'layer04': layer04,
'layer05': layer05,
'layer01_count': layer01Count,
'layer02_count': layer02Count,
'layer03_count': layer03Count,
'layer04_count': layer04Count,
'layer05_count': layer05Count,
'is_file': is_file,
})
def register_exist(request):
uname = request.GET.get('uname')
count = UserInfo.objects.filter(uname=uname).count()
return JsonResponse({'count':count})
def get_hotcommunity(request):
date1 = request.GET.get('date1')
date2 = request.GET.get('date2')
ans = hotcommunity(date1, date2)
print(ans)
return JsonResponse(ans)
def getdata_abnormal(request):
count, ans = getabnormal()
response = {}
response['number'] = count
response['data'] = ans
return JsonResponse(response,safe=False)
def get(self, request):
"""
:param request:
:param pk: 路径传参，可以使用PK获取参数
:return:
"""
# data={
# "name":'小明',
# 'age':16
# }
# # HttpResponse，第一个参数为响应体内容
#
# # return HttpResponse(content=data,content_type='application/json',status=201,)
# return JsonResponse(data=data,content_type='application/json',status=201)
# 创建数据
# 方法一
# 创建模型类对象
# one_obj = Projects(name='这是一个牛逼的项目4',leader='icon',tester='小明1'
# ,programer='若言',publish_app='厉害的项目',desc='描述')
# # 保存
# one_obj.save()
# # 方法二
# Projects.objects.create(name='这是一个牛逼的项目5',leader='icon',tester='小明1'
# ,programer='若言',publish_app='厉害的项目',desc='描述')
# 获取数据
# 方法一获取所有数据,返回一个QuerySet查询集
# h = Projects.objects.all()
# print(h[:1])
# for i in h:
# print(i.name)
# 1获取特定某个指定的记录
'''
1.get返回的是一个模型类对象
2.get只能查询一条数据，查询结果出现多条或者不存在就会报错
3，get主要用于主键和唯一值的查询
'''
# one_Projecr = Projects.objects.get(id=3)
# 2读取部分数据 filter,exclude
"""
filter : 返回满足条件的查询集合
exclude : 返回不满足条件的查询集合
"""
# #读取id为1的数据
# qs = Projects.objects.filter(id=1)
# #读取ID不为1的数据
# qs1 = Projects.objects.exclude(id=1)
# 3模糊查询
# mh = Projects.objects.filter(leader__contains='icon') #包含icon
# mh1 = Projects.objects.filter(leader__icontains='con') #忽略查询结果的大小写icon
# mh2 = Projects.objects.filter(leader__startswith='i') #i开头的
# mh3 = Projects.objects.filter(leader__istartswith='') # 忽略大小
# mh4 = Projects.objects.filter(leader__endswith='n') #n结尾的
# mh5 = Projects.objects.filter(leader__iendswith='n')
# mh6 = Projects.objects.filter(leader__regex='') #正则匹配
# mh7= Projects.objects.filter(leader__iregex='')
# mh8 = Projects.objects.filter(leader__exact='icon') #精确匹配
# mh9 = Projects.objects.filter(leader__iexact='icon')
# mh10 = Projects.objects.filter(leader__in=['icon','宋茜'])#包含
# 4关联查询
'''
格式 外键字段__从表字段名__
如果是多个表 A表__C表__从表字段名_
'''
# qs = Projects.objects.filter(project2s__name__contains='创建项目')
# 5比较查询
"""
__gt 大于
__gte 大于等于
__lt 小于
__lte 小于等于
返回查询集
"""
# qs = Projects.objects.filter(id__gt=3)
# 6逻辑查询
'''
可以组合& 和| 操作符以及使用括号进行分组来编写任意复杂的Q 对象
允许组合正常的查询和取反(NOT) 查询 '~'
'''
# qs1 =Projects.objects.filter(name='接口自动',leader='宋茜') #且的关系
# from django.db.models import Q
# qs1 = Projects.objects.filter(Q(leader='icon')|Q(leader='宋茜')) #或的关系
# qs2 = Projects.objects.filter(Q(leader='icon')&~Q(tester='魏书')) #and的
# 7.查询集的操作
"""
7.1 查询集相当与一个列表，支持列表的大多数就操作（数字索引，正向切片，for循环）
7.2 查询集是对数据库的一种操作
7.3 查询及会缓存结果
7.4 惰性查询
7.5 查询集支持链式操作
first() 第一个
"""
# #获取链式查询的第一个结果
# qs = Projects.objects.filter(leader__contains='icon').filter(tester__contains='小明1').first()
# qs = Projects.objects.filter(leader__contains='icon').filter(tester__contains='小明1').last()
# 更新数据
"""
1.获取要修改的数据
2.修改
3.保存
"""
# one_project = Projects.objects.get(id=2)
# one_project.name = '接口自动化项目'
# one_project.save()
# #删除数据
# """
# 1.获取要删除的模型对象
# 2.删除
# 3.保存
# """
# one_project = Projects.objects.get(id=5)
# one_project.delete() #调用时自动保存
# 排序操作
# '''
# 默认是升序
# 降序加'-'
# 当地一个字段相同看第二个字段
# '''
# Projects.objects.filter(id__gt=3).order_by('-name','leader')
# 聚合查询
'''
aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符
，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。
为聚合值指定一个名称 名称 = 集合值标识符()
'''
# from django.db.models import Max,Avg,F,Q,Min,Sum
# qs = Projects.objects.all().aggregate(idmax = Max('id'),idmin=Min('id'),idavg = Avg('id'),
# idsum =Sum('id'))
# F查询两个字段的值做比较
"""
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
# """
# from django.db.models import F
# qs = Projects.objects.filter(leader=F('tester'))
return JsonResponse('完成', safe=False)
def get_date_event(request):
date1 = request.GET.get('date1')
date2 = request.GET.get('date2')
ans = propertybydate(date1, date2)
print(ans)
return JsonResponse(ans)
def render_to_json_response(self, context, **response_kwargs):
return JsonResponse(self.get_data(context), **response_kwargs)
def todos(request):
todos_list = Todo.objects.all()
data = {"todos": list(todos_list.values("todo", "done"))}
return JsonResponse(data)
def single_todo(request, pk):
todo = get_object_or_404(Todo, pk=pk)
data = {"todo": todo.todo, "done": todo.done}
return JsonResponse(data)
def run_prediction(request, **kwargs):
if request.method == 'GET':
file_url = request.GET.get('file_url', None)
if file_url is not None:
return JsonResponse({'pred': pointnet_run_prediction(file_url)})
def getabnormal_plus(request):
cnt, ans = getabnormal_form()
ans['cnt'] = cnt
return JsonResponse(ans, safe=False)
def get_response(self):
return JsonResponse(data={
'message': self.message,
},
status=self.http_code)
def get_name(request):
res = {}
res['name'] = username_logined
# res['image']='../../assets/'+username_logined+'.png'
return JsonResponse(res)
def get_product_price(request, pk):
if request.is_ajax():
product = Product.objects.filter(pk=int(pk)).first()
if product:
return JsonResponse({'price': product.price})
return JsonResponse({'price': 0})
def move(request):
dirs = {"n": "north", "s": "south", "e": "east", "w": "west"}
reverse_dirs = {"n": "south", "s": "north", "e": "west", "w": "east"}
player = request.user.player
player_id = player.id
player_uuid = player.uuid
data = json.loads(request.body)
direction = data["direction"]
room = player.room()
nextRoomID = None
if direction == "n":
nextRoomID = room.n_to
elif direction == "s":
nextRoomID = room.s_to
elif direction == "e":
nextRoomID = room.e_to
elif direction == "w":
nextRoomID = room.w_to
if nextRoomID is not None and nextRoomID > 0:
nextRoom = Room.objects.get(id=nextRoomID)
player.currentRoom = nextRoomID
player.save()
players = nextRoom.playerNames(player_id)
currentPlayerUUIDs = room.playerUUIDs(player_id)
nextPlayerUUIDs = nextRoom.playerUUIDs(player_id)
for p_uuid in currentPlayerUUIDs:
pusher.trigger(
f"p-channel-{p_uuid}",
"broadcast",
{"message": f"{player.user.username} has walked {dirs[direction]}."},
)
for p_uuid in nextPlayerUUIDs:
pusher.trigger(
f"p-channel-{p_uuid}",
"broadcast",
{
"message": f"{player.user.username} has entered from the {reverse_dirs[direction]}."
},
)
return JsonResponse(
{
"name": player.user.username,
"title": nextRoom.title,
"description": nextRoom.description,
"players": players,
"error_msg": "",
},
safe=True,
)
else:
players = room.playerNames(player_id)
return JsonResponse(
{
"name": player.user.username,
"title": room.title,
"description": room.description,
"players": players,
"error_msg": "You cannot move that way.",
},
safe=True,
)
def info(self, request, *args, **kwagrs):
res = self.info_apps(request)
if isinstance(res, str):
return JsonResponse({'msg': res, "code": 500, 'data': []})
return JsonResponse({'msg': "添加成功", "code": 200, 'data': res})
def post(self, request, *args, **kwargs):
super(CategoryDeleteView, self).post(request, *args, **kwargs)
return JsonResponse({'state': 'success'})
def add_guest(request):
"""
添加嘉宾
:param requset: event_id, realname, phone, email, sign
:return:
"""
if request.method == "POST":
# # 获取前端以form表单方式传的参数
# event_id = requset.POST.get("event_id", "")
# realname = requset.POST.get("realname", "")
# phone = requset.POST.get("phone", "")
# email = requset.POST.get("email", "")
# sign = requset.POST.get("sign", "")
# 获取前端以json方式传的参数
guest_dict = json.loads(request.body)
try:
event_id = guest_dict["event_id"]
realname = guest_dict["realname"]
phone = guest_dict["phone"]
email = guest_dict["email"]
sign = guest_dict["sign"]
except KeyError:
return JsonResponse({"status": 500, "message": "字段不能为空"})
# print(type(event_id))
# 对各个字段进行空字符串判断，并返回给前台
if event_id == "" or realname == "" or phone == "" or email == "":
return JsonResponse({"status": 101, "message": "请求参数为空"})
# 对event_id字段的类型进行判断，必须传整型
if type(event_id) != int:
return JsonResponse({"status": 102, "message": "event_id参数类型有误"})
"""
此处需要对入参中的event_id参数进行校验，如果入参event_id的值不能和库中event_id匹配，
则代表该event_id不存在，无法新增嘉宾
"""
# 查询所有的发布会
guests = Guest.objects.all()
# 定义一个空数组
guest_list = []
# 通过for循环拿到所有的id，并添加到数组中
for guest in guests:
guest_list.append(guest.id)
# 判断入参的event_id是否存在于guest_list中，如果不存在，则只需if语句块，返回对应json
if event_id not in guest_list:
return JsonResponse({"status": 103, "message": "发布会id不存在"})
# 对sign字段做空字符串判断，如果为真，则默认sign=0
if sign == "":
sign = 0
# 对sign字段的类型进行判断，必须传整型
if type(sign) != int:
return JsonResponse({"status": 104, "message": "sign参数类型有误"})
# 对sign字段的数据进行判断，必须传0或1
"""
注意：此处应该用and
1. 在纯and语句中，如果每一个表达式都不是假的话，那么返回最后一个，因为需要一直匹配直到最后一个。如果有一个是假，那么返回假
2. 在纯or语句中，只要有一个表达式不是假的话，那么就返回这个表达式的值。只有所有都是假，才返回假
3. 在or和and语句比较难表达，总而言之，碰到and就往后匹配，碰到or如果or左边的为真，那么就返回or左边的那个值，如果or左边为假，继续匹配or右边的参数。
"""
if sign != 0 and sign != 1:
print(sign)
return JsonResponse({"status": 105, "message": "sign参数只能为0或1"})
# 根据入参的name和数据库中的name进行模糊比对，如相同，则返回相应的错误信息
guest = Guest.objects.filter(phone=phone)
# 如果name相同
if guest:
return JsonResponse({"status": 106, "message": "手机号已存在"})
# 新增一条发布会信息
Guest.objects.create(event_id=event_id,
realname=realname,
phone=phone,
email=email,
sign=sign)
# 如果所有校验均通过，则创建一条发布会，并返回
return JsonResponse({"status": 200, "message": "新增嘉宾成功"})
else:
# 如果请求方式不是post，则抛出此信息
return JsonResponse({"status": 100, "message": "请求方式有误"})
def lastData(request):
global changeRates,bankValues
return JsonResponse([changeRates,bankValues],safe=False,json_dumps_params={'ensure_ascii': False})
def get_all_business(request, *args, **kwargs):
empresas = Empresa.objects.all()
serializer = EmpresaSerializer(empresas, many=True)
return JsonResponse(serializer.data, safe=False)
def run_segmentation(request, **kwargs):
if request.method == 'GET':
file_url = request.GET.get('file_url', None)
if file_url is not None:
return JsonResponse({'segmented_file_path': pointnet_run_segmentation(file_url)})
def index(request):
"""
This method will return all deployments when
responding to a GET request, it will create
a new deployment when responding to a POST
request and will return a 404 not found on
any other method. User authentication is required
"""
if not request.user.is_authenticated:
return JsonResponse({'message': 'You are not logged in.'}, status=403)
# Now check if this is a POST or GET request
if request.method == 'GET':
# We kow that they are logged in now
# So send them all of the deployment models
return JsonResponse(serializers.serialize("json",
Deployment.objects.all()),
safe=False)
elif request.method == 'POST':
#try:
params = json.loads(request.body.decode('utf-8'))
name = params['name']
git = params['git']
dirt = params['dir']
run = params['run']
cport = params['cport']
lport = params['lport']
create_new_key = params['gen_new_key']
compose = params['compose']
git_name = parse_git_url(git)
# Make sure we have a valid git name
if git_name == '':
return JsonResponse(
{
'message': 'invalid git url',
'reason': 'bad_git_url'
},
status=400)
# Replace copied ssh with proper ssh
#if "*****@*****.**" in git:
# git = "ssh://" + git
# append our repo name to our dir name
if dirt.endswith('/'):
dirt = dirt + git_name
else:
dirt = dirt + '/' + git_name
# awesome, now lets create our custom url
webhook = hashlib.md5((params['name'] + SUPER_SECRET_KEY).encode())
# First see if we need to generate an ssh key
# If we do we cannot pull automatically
if create_new_key:
generate_ssh_key(dirt)
else:
# Let's try to clone our repo
try:
clone_repository(git, dirt)
except GitError:
return JsonResponse(
{
'message': 'invalid git url',
'reason': 'bad_git_url'
},
status=400)
except ValueError:
return JsonResponse(
{
'message':
'invalid directory, perhaps the destination folder exists?',
'reason': 'bad_dir'
},
status=400)
d = Deployment.objects.create(name_text=name,
git_url_text=git,
dir_text=dirt,
is_running=run,
webhook_text=webhook.hexdigest(),
container_port=cport,
local_port=lport,
is_compose=compose)
return JsonResponse({'message': 'success', 'id': d.id})
'''except Exception as e:
print(e)
print(e.__class__.__name__)
return JsonResponse({'message': 'Invalid params'}, status=400)'''
else:
return JsonResponse({'message': 'Unknown method'}, status=404)
def remove_tmp(request, **kwargs):
if request.method == 'GET':
if remove_file(request.GET.get('tmp_file_url', None)):
return JsonResponse({"success": request.GET.get('tmp_file_url', "False bro")})
return JsonResponse({"success": "failed"})
def ActividadesJson(request):
actividades = Actividades.objects.all()
return JsonResponse(actividades, safe=False)
def get(self, request, *args, **kwargs):
queryset = Sites.objects.all().values()
return JsonResponse({"site": list(queryset)})
