courseCycleCard.py

# coding: utf-8
'''
@author: v.popov
'''
import datetime
from java.text import SimpleDateFormat
import json
import uuid

from com.jayway.jsonpath import JsonPath
from edu._edu_orm import vw_course_cycleCursor, course_cycleCursor, courseCursor, cycle_edu_baseCursor
from nci._nci_orm import org_addressCursor,  edu_organizationCursor, education_formCursor, education_baseCursor, cycle_addressCursor
from ru.curs.celesta.showcase.utils import XMLJSONConverter
from security.functions import userHasPermission
from fias.xforms.addressSearch import addressSearchDict, addressEditDict, saveAdress
from medstaff._medstaff_orm import student_cycleCursor

try:
    from ru.curs.showcase.core.jython import JythonDTO
    from ru.curs.showcase.app.api import MessageType, UserMessage
except:
    from ru.curs.celesta.showcase import JythonDTO


def cardData(context, main=None, add=None, filterinfo=None, session=None, elementId=None):
    u'''Карточка цикла по курсу'''    
    session = json.loads(session)
    vw_course_cycle = vw_course_cycleCursor(context)
    course_cycle = course_cycleCursor(context)
    cycle_address = cycle_addressCursor(context)
    edu_cursor = edu_organizationCursor(context)
    course = courseCursor(context)
    
#     edu_formCursor = education_formCursor(context)
    edu_baseCurs = education_baseCursor(context)
    cycle_edu_base = cycle_edu_baseCursor(context)
    
    org_address = org_addressCursor(context)
    
    edu_form_name = ""
    bases = ""
    
    courseId = main
    course.get(courseId)
    courseName = course.name
    
    u"""Получение данныъ об адресе"""
    edu_org_id = course.edu_organization_id
    edu_cursor.get(edu_org_id)
    address_id = edu_cursor.address_id
    org_address.get(address_id)
    region = org_address.region_name if org_address.region_name else ''
    city = org_address.city_name if org_address.city_name else ''
    place = (org_address.street_name if org_address.street_name else '') + ', ' + (org_address.address_additional if org_address.address_additional else '')
    
    u"""Согласование поля ДОТ и ЭО с идентичным полем в таблице программ"""
    if add == "add":
        address = addressSearchDict().get('address')
        if course.dot_and_eo:
            dot_and_eo = "true"
        else:
            dot_and_eo = "false"

        dot_and_eo_description = ''
    
    if add == 'edit':
        record_id = session["sessioncontext"]["related"]["gridContext"]["currentRecordId"]
        course_cycle.get(record_id)
        vw_course_cycle.setRange('uid', record_id)
        vw_course_cycle.findSet()
        
        if course.dot_and_eo or vw_course_cycle.dot_and_eo:
            dot_and_eo = "true"
        else:
            dot_and_eo = "false"

        if dot_and_eo == "true" and vw_course_cycle.dot_and_eo and not course.dot_and_eo: 
            dot_and_eo_description = vw_course_cycle.dot_and_eo_description
        elif dot_and_eo == "true" and course.dot_and_eo: 
            dot_and_eo_description = course.dot_and_eo_description
        else:
            dot_and_eo_description = ''
            
        if not course_cycle.outside:
            address = addressSearchDict().get('address')
        else:
            if cycle_address.tryGet(course_cycle.uid):
                address = addressEditDict(context, cycle_address).get("address")
            else:
                address = addressSearchDict().get('address')
        
        u"""Получение названия формы обучения для цикла"""
#         edu_formCursor.setRange("id",vw_course_cycle.education_form_id)
#         edu_formCursor.findSet()
#         edu_form_name = edu_formCursor.name
        edu_form_name = ''
        
        u"""Поиск записей в составной таблице программ и основ обучения 
        (для заполнения мультиселектора).
        Отбор основ обучения для заданной программы"""
        cycle_edu_base.setRange("cycle_id",record_id)
        if cycle_edu_base.count() > 0:
            prebases = []
            u"""Поиск названий форм обучения по id"""
            for base in cycle_edu_base.iterate():
                id = base.edu_base_id
                edu_baseCurs.get(id)
                edu_base_name = edu_baseCurs.name
                prebases.append({"@id": id,
                              "@name": edu_base_name})
            bases = {"base": prebases}
        
    df = SimpleDateFormat("yyyy-MM-dd")

    xformsdata = {"schema":
                    {"@xmlns":"",
                     "record": {
                        "uid": vw_course_cycle.uid,
                        "course_name": courseName,
                        "course_id": courseId,
                        "education_form_id": int(vw_course_cycle.education_form_id) if vw_course_cycle.education_form_id else '',
                        "education_form": edu_form_name,
                        "edu_bases":bases,
                        "start_date": df.format(vw_course_cycle.start_date) if vw_course_cycle.start_date else '',
                        "end_date": df.format(vw_course_cycle.end_date) if vw_course_cycle.end_date else '',
                        "budget_places": int(vw_course_cycle.budget_places) if vw_course_cycle.budget_places else 0,
                        "paid_places": int(vw_course_cycle.paid_places) if vw_course_cycle.paid_places else 0,
                        "outside": "true" if vw_course_cycle.outside else "false",
                        "region": region,
                        "city": city,
                        "place": place,
                        "phone": vw_course_cycle.org_email,
                        "org_email": vw_course_cycle.org_email,
                        "dot_and_eo": dot_and_eo,
                        "course_dot_and_eo": "true" if course.dot_and_eo else "false",
                        "block_dot": "true" if course.dot_and_eo else "false",
                        "clinic_base": vw_course_cycle.clinic_base,
                        "note": vw_course_cycle.note,
                        "order": vw_course_cycle.cycle_order,
                        "dot_and_eo_description": dot_and_eo_description,
                        "error_flag": "false"},
                    'address':address}}
    

    xformssettings = {"properties": 
                        {"event":[
                            {"@name":"single_click", 
                             "@linkId": "1",
                             "action": {
                                "@keep_user_settings": "true",
                                '#sorted': [
                                    {"main_context": "current"},
                                    {'navigator': {
                                        '@refresh': 'true'}},
                                    {"datapanel": {
                                        "@type": "current",
                                        "@tab": "current",
                                        "element": {"@id":"courseCycleGrid",
                                        "add_context": ""}}}]}}]}}
    
    xformssettings["properties"]["event"].append({"@name": "single_click",
                                                  "@linkId": "2",
                                                  "action": {
                                                      "@keep_user_settings": "true",
                                                      '#sorted': [
                                                          {"main_context": "current"},
                                                          {"datapanel": {
                                                              "@type": "current",
                                                              "@tab": "current",
                                                              "element": [
                                                                  {"@id": elementId,
                                                                   "add_context": "hide"}]}}]}})

    return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xformsdata)),
                     XMLJSONConverter.jsonToXml(json.dumps(xformssettings)))

def cardSave(context, main=None, add=None, filterinfo=None, session=None, elementId=None, xformsdata=None):
    u'''Сохранение данных о КДПП. '''
    session = json.loads(session)
    data_dict = json.loads(xformsdata)["schema"]    
    sid = session['sessioncontext']['sid']
    u"""Курсор для таблицы циклов и основ обучения"""
    cycle_edu_base = cycle_edu_baseCursor(context)

    u"""Курсор для таблицы циклов"""
    course_cycle = course_cycleCursor(context)
    
    u'''Проверка на номер темы'''
    cycle_order = data_dict["record"]["order"]
    course_id = data_dict["record"]["course_id"]
    course_cycle.setRange('course_id', course_id)
    course_cycle.setRange('cycle_order', cycle_order)
    course_cycle.setFilter('uid', "!'{}'".format(data_dict["record"]["uid"]))
    if course_cycle.tryFirst():
        context.error(u'Тема с номером {} уже существует'.format(cycle_order))
    
    cycle_address = cycle_addressCursor(context)


    if data_dict["record"]["uid"] == '':
        # Добавление новой записи
        course_cycle.uid = uuid.uuid4()
        course_cycle.course_id = course_id
#         course_cycle.start_date = datetime.datetime.strptime(data_dict["record"]["start_date"], "%Y-%m-%d") if data_dict["record"]["start_date"] else ''
#         course_cycle.end_date = datetime.datetime.strptime(data_dict["record"]["end_date"], "%Y-%m-%d") if data_dict["record"]["end_date"] else ''
        if userHasPermission(context,sid,'allEduOrgCourse'):#Если методист создёт цикл, то статус "Сформирован"
            course_cycle.status_id = 4
        else:
            course_cycle.status_id = 0
#         course_cycle.education_form_id = data_dict["record"]["education_form_id"]
#         course_cycle.budget_places = int(data_dict["record"]["budget_places"])
#         course_cycle.paid_places = int(data_dict["record"]["paid_places"])
        course_cycle.dot_and_eo = True if data_dict["record"]["dot_and_eo"] == "true" else False
        course_cycle.outside = True if data_dict["record"]["outside"] == 'true' else False
        course_cycle.dot_and_eo_description = data_dict["record"]["dot_and_eo_description"]\
        if data_dict["record"]["dot_and_eo"] == "true" else ''
        course_cycle.note = data_dict["record"]["note"]
        course_cycle.cycle_order = cycle_order
        
        if course_cycle.outside:
            cycle_address.cycle_id = course_cycle.uid
            saveAdress(cycle_address, data_dict["address"])
            cycle_address.insert()
        
        course_cycle.insert()
    else:
        # Редактирование уже существующей
        course_cycle.get(data_dict["record"]["uid"])
        course_cycle.course_id = course_id
#         course_cycle.education_form_id = int(data_dict["record"]["education_form_id"])
#         course_cycle.budget_places = int(data_dict["record"]["budget_places"])
#         course_cycle.paid_places = int(data_dict["record"]["paid_places"])
#         course_cycle.start_date = datetime.datetime.strptime(data_dict["record"]["start_date"], "%Y-%m-%d") if data_dict["record"]["start_date"] else ''
#         course_cycle.end_date = datetime.datetime.strptime(data_dict["record"]["end_date"], "%Y-%m-%d") if data_dict["record"]["end_date"] else ''
        course_cycle.dot_and_eo = True if data_dict["record"]["dot_and_eo"] == "true" else False
        course_cycle.outside = True if data_dict["record"]["outside"] == 'true' else False
        course_cycle.dot_and_eo_description = data_dict["record"]["dot_and_eo_description"]
        course_cycle.note = data_dict["record"]["note"]
        course_cycle.cycle_order = cycle_order
        
        if course_cycle.outside:
            if cycle_address.tryGet(course_cycle.uid):
                saveAdress(cycle_address, data_dict["address"])
                cycle_address.update()
            else:
                cycle_address.cycle_id = course_cycle.uid
                saveAdress(cycle_address, data_dict["address"])
                cycle_address.insert()
        course_cycle.update()
        u"""Отбор основ обучения для заданного цикла"""
        cycle_edu_base.setRange("cycle_id", course_cycle.uid)
        u"""Удаление найденных записей"""
        cycle_edu_base.deleteAll()

    u"""Получение списка основ обучения по данной программе"""
    if "base" in data_dict["record"]["edu_bases"]:
        data_base_store = data_dict["record"]["edu_bases"]["base"]
    else:
        data_base_store = None
        
    if not isinstance(data_base_store, list) and data_base_store:
        data_base_store = [data_base_store]
        
    u"""Обновление записей(вставка)"""
    if data_base_store:   
        eduBaseInsert(cycle_edu_base,data_base_store,course_cycle.uid)
        


def eduBaseInsert(cycle_edu_base,data_base_store,uid):
    u"""Добавление записей в составную таблицу программ и основ обучения"""
    for base in data_base_store:
        cycle_edu_base.cycle_id = uid
        cycle_edu_base.edu_base_id = base['@id']
        cycle_edu_base.insert()
        

def deleteCardData(context, main=None, add=None, filterinfo=None, session=None, elementId=None):
    u'''Данные для карточки.'''

    string_bool = lambda x: x and 'true' or 'false'

    # Структура данных
    xforms_data = {'schema': {
            '@xmlns': '',
            'data': {
                'form_text': 'Вы действительно хотите удалить запись о цикле по программе ПК?'}}}

    # Первоначальная xforms_settings
    xforms_settings = {
        'properties': {
            'event': [
                {'@name': 'single_click',
                 '@linkId': '1',
                 'action': {
                    '@keep_user_settings': 'false',
                    '#sorted': [
                        {'main_context': 'current'},
                        {'navigator': {
                            '@refresh': 'true'}},
                        {'datapanel': {
                            '@type': 'current',
                            '@tab': 'current',
                            'element': {
                                '@id': 'courseCycleGrid',
                                'add_context': ''}}}]}},
                {'@name': 'single_click',
                 '@linkId': '2',
                 'action': {
                    '@keep_user_settings': 'true',
                    '#sorted': [
                        {'main_context': 'current'},
                        {'datapanel': {
                            '@type': 'current',
                            '@tab': 'current',
                            'element': {
                                '@id': elementId,
                                'add_context': 'hide'}}}]}}]}}

    return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xforms_data)),
                     XMLJSONConverter.jsonToXml(json.dumps(xforms_settings)))


def deleteCardSave(context, main=None, add=None, filterinfo=None, session=None, elementId=None, xformsdata=None):
    u'''Сохранение карточки. '''
    cycle_id = json.loads(session)['sessioncontext']['related']['gridContext']['currentRecordId']
    
    studentCycleCur = student_cycleCursor(context)
    studentCycleCur.setRange('cycle_id', cycle_id)
    if studentCycleCur.tryFirst():
        context.error(u'По данной теме уже проходят обучение.')
    
    course_cycle = course_cycleCursor(context)
    cycle_edu_base = cycle_edu_baseCursor(context)
    if course_cycle.tryGet(cycle_id):
        course_cycle.delete()
        
        u"""Поиск записей о формах и основах обучения по заданной программе"""
        cycle_edu_base.setRange("cycle_id", cycle_id)
        u"""Удаление"""
        cycle_edu_base.deleteAll()