def service_list(request):
"""
Lists all the services , or create a new services
"""
if request.method == 'GET':
services = Service.objects.all()
serializer = ServiceSerializer(services, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = ServiceSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(request):
result = Result()
service_id = request.POST.get('service_id')
if service_id:
service_dict = cache.get(create_key(CACHE_SERVICE, service_id))
result.data = service_dict
return JsonResponse(result.serializer())
service_name = request.POST.get('service_name')
if service_name:
service_dict = cache.get(create_key(CACHE_SERVICE_NAME, service_name))
result.data = service_dict
return JsonResponse(result.serializer())
service_list = Service.objects.all()
service_dicts = dict()
for service in service_list:
service_dict = ServiceSerializer(service).data
service_dict_cache_by_id = cache.get(create_key(CACHE_SERVICE, service.id))
if not service_dict_cache_by_id:
cache.set(create_key(CACHE_SERVICE, service.id), service_dict, timeout=None)
service_dict_cache_by_name = cache.get(create_key(CACHE_SERVICE_NAME, service.service_name))
if not service_dict_cache_by_name:
cache.set(create_key(CACHE_SERVICE_NAME, service.service_name), service_dict, timeout=None)
service_dicts[service.service_name] = service_dict
result.data = service_dicts
return JsonResponse(result.serializer())
class ProfessionalServiceSerializer(serializers.ModelSerializer):
profesional = ProfessionalSerializer()
service = ServiceSerializer()
class Meta:
model = ProfessionalService
fields = '__all__'
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset().order_by(
'order_in_list', '-created_date'))
services = ServiceSerializer(queryset,
many=True,
context={'request': request})
kaz = [d['kaz'] for d in services.data]
rus = [d['rus'] for d in services.data]
return Response({'kaz': kaz, 'rus': rus})
def service(self, request, pk=None):
token = self.get_object()
if token.status == 'TAR':
response = ServiceSerializer(token.service).data
else:
raise TokenNotArchivedException()
return Response(response)
def service_detail(request, pk):
"""
Retrieve, update or delete service
"""
try:
service = Service.objects.get(pk=pk)
except Service.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = ServiceSerializer(service)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = ServiceSerializer(service, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
service.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def tampilkan_laporan(modeladmin, request, queryset):
serializer = ServiceSerializer(queryset, many=True)
querysetByDay = Service.objects.filter(
id__in=queryset).values('date__date').annotate(
cost=Sum('cost'),
gross=Sum('price'),
)
serializerByDay = ServiceByDaySerializer(querysetByDay, many=True)
context = {
'services': dumps(serializer.data),
'servicesByDay': dumps(serializerByDay.data)
}
return TemplateResponse(request, 'services/template_report.html', context)
def put(request):
result = Result()
service_name = request.POST.get('service_name')
if not service_name or not re.match("^[A-Za-z]+(_[0-9]+)?$", service_name):
result.code = CODE_SYS_TIPS
result.message = "service_name format error"
return JsonResponse(result.serializer())
service_name = service_name.lower()
domain = request.POST.get('domain')
port = request.POST.get('port')
service_uri = request.POST.get('service_uri')
meta = request.POST.get('meta')
status = request.POST.get('status')
language = request.POST.get('language')
language = language if not language else 'EN'
# 访问秘钥
secret = encrypt.digest_random()
secret = encrypt.digest(secret)
try:
with transaction.atomic():
service = Service(service_name=service_name, domain=domain, port=port, service_uri=service_uri,
meta=meta, secret=secret, status=status)
service.save()
service_dict = ServiceSerializer(service).data
cache.set(create_key(CACHE_SERVICE, service.id), service_dict, timeout=None)
cache.set(create_key(CACHE_SERVICE_NAME, service_name), service_dict, timeout=None)
result.data = service_dict
except Exception as e:
log.error(e)
result.code = CODE_SYS_DB_ERROR
result.message = get_error_message(result.code, language)
return JsonResponse(result.serializer())
class OrderServiceSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(required=False)
pet = serializers.PrimaryKeyRelatedField(
queryset=CustomerPets.objects.all(), many=False, required=True)
service = serializers.PrimaryKeyRelatedField(
queryset=Services.objects.all(), many=False, required=True)
staff = serializers.PrimaryKeyRelatedField(queryset=User.objects.all(),
many=False,
required=False)
service_details = ServiceSerializer(many=False,
read_only=True,
source='service')
pet_details = CustomerPetSerializer(many=False,
read_only=True,
source='pet')
staff_details = StaffSerializer(many=False, read_only=True, source='staff')
class Meta:
model = OrderServices
fields = ('id', 'service', 'service_details', 'pet_details', 'pet',
'price', 'start_time', 'duration', 'staff', 'staff_details')
depth = 1
def get_services(self, request, **kwargs):
if request.GET.get('source') == 'master':
logger.info('Getting infomation was called')
agent = request.GET.get('agent')
detail = request.GET.get('detail')
services = Service.objects.all()
# for service in services:
# return render_to_response(
# 'service_manage.html', {
# 'username': request.user.username, 'show_list': services})
return Response(ServiceSerializer(services).data,
status=status.HTTP_200_OK)
else:
logger.info('Getting infomation was called')
agent = request.GET.get('agent')
detail = request.GET.get('detail')
services = Service.objects.all()
# for service in services:
return render_to_response('service_manage.html', {
'username': request.user.username,
'show_list': services
})
class ServiceLineComponentSerializer(serializers.ModelSerializer):
service = ServiceSerializer(many=False)
class Meta:
model = ServiceLineComponent
fields = "__all__"
def post(request):
result = Result()
service_id = request.POST.get('service_id')
if not service_id:
result.code = CODE_SYS_TIPS
result.message = "service_id can't be empty"
return JsonResponse(result.serializer())
service_name = request.POST.get('service_name')
if service_name and not re.match("^[A-Za-z]+(_[0-9]+)?$", service_name):
result.code = CODE_SYS_TIPS
result.message = "service_name format error"
return JsonResponse(result.serializer())
if service_name:
service_name = service_name.lower()
domain = request.POST.get('domain')
port = request.POST.get('port')
service_uri = request.POST.get('service_uri')
meta = request.POST.get('meta')
status = request.POST.get('status')
service = Service()
service.__dict__ = cache.get(create_key(CACHE_SERVICE, service_id))
# 修改标记
update_flag = 0
if service_name and service.service_name != service_name:
update_flag += 1
service.service_name = service_name
elif domain and service.domain != domain:
update_flag += 1
service.domain = domain
elif port and service.port != int(port):
update_flag += 1
service.port = port
elif service_uri and service.service_uri != service_uri:
update_flag += 1
service.service_uri = service_uri
elif meta and service.meta != meta:
update_flag += 1
service.meta = meta
elif status and service.status != int(status):
update_flag += 1
service.status = status
if update_flag == 0:
result.code = CODE_SYS_TIPS
result.message = "nothing to be updated"
return JsonResponse(result.serializer())
language = request.POST.get('language')
language = language if not language else 'EN'
result = Result()
try:
with transaction.atomic():
count = Service.objects.filter(id=service_id).update(service_name=service.service_name,
domain=service.domain,
port=service.port, service_uri=service.service_uri,
meta=service.meta, status=service.status)
service_dict = ServiceSerializer(service).data
cache.set(create_key(CACHE_SERVICE, service.id), service_dict, timeout=None)
cache.set(create_key(CACHE_SERVICE_NAME, service_name), service_dict, timeout=None)
result.data = count
except Exception as e:
log.error(e)
result.code = CODE_SYS_DB_ERROR
result.message = get_error_message(result.code, language)
return JsonResponse(result.serializer())
def available_services(self, request, pk=None):
department = self.get_object()
serializer = ServiceSerializer(department.available_services.all(),
many=True)
return Response(serializer.data)
class ProfessionalSerializer(serializers.ModelSerializer):
services = ServiceSerializer(many=True)
class Meta:
model = Professional
fields = '__all__'
def create_service(request, **kwargs):
service_name = request.POST.get('service_name')
instance_amount = request.POST.get('instance_amount')
# ip= request.POST.get('ip')
if not instance_amount:
instance_amount = '1'
image_name = request.POST.get('image_name')
if not image_name:
image_name = 'docker.weitac.com/centos7/haproxy:0.2'
environment = request.POST.get('environment')
if not environment:
environment = None
hostname = request.POST.get('hostname')
if not hostname:
environment = 'haproxy.weitac.com'
command = request.POST.get('command')
if not command:
command = '/usr/sbin/init'
volumes = request.POST.get('volumes')
if not volumes:
volumes = './conf:/etc/haproxy'
if request.method == 'POST':
logger.info('Create a service: {}'.format(service_name))
data = {
'service_name': service_name,
'instance_amount': instance_amount,
'image_name': image_name,
'details': 'dd'
}
# if isinstance(request.DATA, QueryDict):
# data = {'service_name': service_name,
# 'instance_amount': instance_amount,
# 'image_name': 'ss', 'details': 'dd'}
#
# elif isinstance(request.DATA, dict):
# data = request.DATA
serializer = ServiceSerializer(data=data)
if not serializer.is_valid():
# return Response(serializer.errors,
# status=status.HTTP_400_BAD_REQUEST)
return render_to_response('400.html')
service = serializer.object
service_name = data['service_name']
instance_amount = data['instance_amount']
if not Service.objects.filter(service_name=service_name).exists():
# serializer.save()
db_info = dict()
db_info['instance'] = []
instance = Instance_client()
for i in range(int(instance_amount)):
# instance_name = service_name + '_{}'.format(i+1)
instance_id = i + 1
bl, result = instance.create_instance \
(service_name, instance_id, image_name, environment, hostname, command, volumes)
if not bl:
return render_to_response('500.html')
if bl:
instance.start_instance(result)
db_info['instance'].append(bl)
# return Response("success",
# status=status.HTTP_200_OK)
else:
# return Response(
# '{}'.format(
# str(result)),
# status=status.HTTP_400_BAD_REQUEST)
render_to_response('400.html')
Instance_client().add_host_info(db_info)
db_info['service'] = service
service_DBclient.save(db_info)
return render_to_response('create_service.html',
{'username': request.user.username})
else:
logger.error('Service {} exits'.format(service_name))
# return Response(
# 'Service {} exits. Do you want to add more instances? Please use update API'.format(
# data['service_name']),
# status=status.HTTP_400_BAD_REQUEST)
return render_to_response('400.html')
else:
return render_to_response('create_service.html',
{'username': request.user.username})
