colab.ipynb

!pip install --upgrade diffusers transformers accelerate safetensors

!pip install flask-ngrok

# Schedule 라이브러리 설치
!pip install schedule
!pip install apscheduler

from google.colab import drive
drive.mount('/content/gdrive')

!mkdir -p /drive/ngrok-ssh
%cd /drive/ngrok-ssh
!wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip -O ngrok-stable-linux-amd64.zip
!unzip -u ngrok-stable-linux-amd64.zip
!cp /drive/ngrok-ssh/ngrok /ngrok
!chmod +x /ngrok

!/ngrok authtoken 2PVboVLSqlNaFpvdaZHjfPCdyCH_6owyCmRtBhg57K9VM8AQv # 자신이 생성한 토큰 입력


# 프로그램 돌리는 부분
from flask import Flask
from flask_ngrok import run_with_ngrok
from flask import Flask, render_template, send_file, request

import torch
from diffusers import StableDiffusionPipeline, DEISMultistepScheduler
from accelerate.utils import set_seed # seed 관련

import base64
from io import BytesIO

import psycopg2

# 타이머 import
import threading
import time
import queue
import datetime
import pytz

thread_queue = queue.Queue()
korea_tz = pytz.timezone('Asia/Seoul')


# pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", revision="fp16", torch_dtype=torch.float16)
# Ojimi/anime-kawai-diffusion --> 애니 스타일 잘 나오게 하는 모델
model_id = "dreamlike-art/dreamlike-anime-1.0"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16, use_safetensors=True)

pipe.to("cuda")

app = Flask(__name__, template_folder='/content/gdrive/MyDrive/project/templates/', static_folder='/content/gdrive/MyDrive/project/static',
            static_url_path='/static')

run_with_ngrok(app)

@app.template_filter('base64_encode')
def base64_encode(value):
    return base64.b64encode(value).decode('utf-8')
@app.route('/')
def view_main():
    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    cur.execute("SELECT a.post_no, b.img, a.post_name FROM posts AS a JOIN cuts AS b ON a.post_no = b.post_no WHERE a.is_done = 5 AND b.cut_order = 1 ORDER BY RANDOM() LIMIT 5;")

    posts = cur.fetchall()

    post_no_list_end = []
    img_list_end = []
    post_name_list_end = []


    for post in posts:
      post_no_list_end.append(post[0])
      img_list_end.append(base64.b64decode(post[1]))
      post_name_list_end.append(post[2])


    return render_template('index.html', idsEnd=post_no_list_end, imagesEnd=img_list_end, titlesEnd = post_name_list_end)


@app.route('/drawing')
def initial():
    # 이미지 URL 목록을 생성하거나 가져옴
    generated_image = [
        'static/images/default.png',
        'static/images/default.png',
        'static/images/default.png',
        'static/images/default.png'
    ]
    return render_template('drawing.html', generated_image=generated_image)


###이부분 seed 값 넘겨주는거까지 고려하여 수정완료
@app.route('/submit-caption', methods=['POST'])
def generate_image() :
    global img_str
    global prompt

    generator = torch.Generator(device="cuda")

    img_str = []
    # 이부분 "디즈니" 버튼 누른경우, 디즈니관련 프롬프트 추가되게 바꿀수도 있을듯 IF 문 쓰고 해서..
    pos_prompt = ', best quality, extremely detailed, 4k, hd, beautiful'
    neg_prompt = 'simple background, duplicate, retro style, low quality, lowest quality, bad anatomy, bad proportions, extra digits, lowres, username, artist name, error, duplicate, watermark, signature, text, extra digit, fewer digits, worst quality, jpeg artifacts'

    prompt = request.form['caption-input']
    print(f"Generating an image of {prompt}")

    all_prompt = prompt + pos_prompt

    # 이미지 4개 생성 하기위한 빈리스트
    global imageList
    imageList = []
    global seedList #seed 리스트
    seedList = []

    seed =None # 시드값 초기화 ##없어도 되는진 모르겠음..
    # 시드 받아오는 코드
    try : # 시도해본다
        seed = request.form.get('seed') # name  값이 'seed' 인 것을 프론트에서 받아온다.
        print('seed 받아오기성공:',seed)
        seed= int(seed)
    except Exception as e : # 실패한다면 ( 프론트에서 받아오는 seed 값이 없다면.. ) #####되는지 확인해봐야함
        seed = None

    #실제 이미지 생성코드
    if seed != None : # 시드값을 받아왔다면
        for i in range (4) :

            seedList.append(seed) # 동일한 시드를 시드 리스트에 더함
            generator = generator.manual_seed(seed)

            image = pipe(prompt=all_prompt, negative_prompt = neg_prompt).images[0]
            print("Image generated! Converting image ...")
            print("seed : %d" % (seed))

            buffered = BytesIO()
            image.save(buffered, format="PNG")

            img_str.append(base64.b64encode(buffered.getvalue()).decode('utf-8'))
            # img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')

            imageName = "data:image/png;base64," + img_str[i] #imageName = "data:image/png;base64," + img_str
            imageList.append(imageName)

            print(buffered)
            print('받아온 시드 로 생성... ')
    else: # seed 가 None 이라면
        print('seed 가 없어서:새로생성')
        for i in range (4) :
            seed = generator.seed() # seed 를 네번, 서로다른걸로 생성
            seedList.append(seed)
            generator = generator.manual_seed(seed)

            image = pipe(prompt=all_prompt, negative_prompt = neg_prompt).images[0]
            print("Image generated! Converting image ...")
            print("seed : %d" % (seed))

            buffered = BytesIO()
            image.save(buffered, format="PNG")

            img_str.append(base64.b64encode(buffered.getvalue()).decode('utf-8'))
            # img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')

            imageName = "data:image/png;base64," + img_str[i] #imageName = "data:image/png;base64," + img_str
            imageList.append(imageName)

            print(buffered)
            print('시드가 없어서 ... 시드를 4번 생성 ')
    print("Sending image ...")

    # order = request.form['for_cut_order']
    # order = int(order)+1
    # if) order가 1이면 drawing.html로 이미지만 return
    # elif) next_drawing.html로 id값과 order도 이미지와 함께 다시 return
    # id = request.form['pose_id']
    # 첫컷은 drawing.html로 return / 다음컷은 next_drawing.html로 이동..
    order=request.form.get('for_cut_order')
    order=str(order)

    id=request.form.get('post_id')
    id=str(id)

    if order == "0":
      return render_template('drawing.html', generated_image=imageList)

    else : # fix된 컷 / 즉 order가 1 이상,,
      order=int(order)+1
      order=str(order)
      return render_template('next_drawing.html', generated_image=imageList, id=id, order=order)


# 첫컷 생성 버튼 눌렀을때 동작 ( 작품 새로 생성 ) -> posts 도 하나 생성 & cuts 도 하나 생성
# 코드리뷰해보고 좀 정리해야할필요 있을듯..
@app.route('/save_image_first', methods=['POST']) ##### 테스팅 완료
##네컷중에 하나만 db에 저장하는 구문
 #(이미지만 cuts랑 posts 테이블에 저장하고,, 그 cuts id를 가져옴 )
def save_imgae_first(): # 테스팅 완료
  #첫컷인 경우 --> ***cut_fixed = ture로 저장되게 수정해야함***
  if request.form.get('action2') == '이 컷으로 만들기':# get('name') = 'value' 형으로 적어야하는듯

    #4개중 한개 선택된 이미지의 인덱스값을 변수에 저장하는 부분 -> modify 페이지 생기면 수정 필요한 부분...(4개중 1개 선택하지 않고 이전 페이지에서 값을 받아오므로)
    num=request.form.get('selected_image')
    num = int(num)
    seedNum = seedList[num] # 선택한 이미지의 인덱스와 같은 번호의 seedList 에 저장된 seed를 seedNum으로 지정
    print("click seed : ", seedNum)
    seedNum = str(seedNum) #seed를 string 형으로
    #print(img_str[num])

    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    title = "생성중입니다."

    #posts 테이블에 작품 명 업로드
    cur.execute("INSERT INTO posts (post_name) VALUES (%s)", (title,))

    # 방금 저장한거의 posts id 번호가져오기
    cur.execute("SELECT currval(pg_get_serial_sequence('posts', 'post_no'))")
    result = cur.fetchone()

    if result is not None:
        postNumber = result[0]
    else:
    # Handle the case when no result is fetched
      print("방금 생성된 작품(post)id 호출 오류")

    conn.commit() # 데이터베이스에 대한 변경 사항을 저장하는 역할


    print(postNumber)
    postNumber = str(postNumber)
    encoded_image = img_str[num]

    #cuts 테이블에 1. post_no 가져온것  + 2. 한컷 이미지 + 3. 프롬프트값 + 4.컷순서(1) + 5. 시드    업로드
    cur.execute("INSERT INTO cuts (post_no, img, cut_prompt,cut_order,cut_seed,cut_fixed) VALUES (%s,%s,%s,%s,%s,%s)", (postNumber,encoded_image,prompt,str(1),seedNum,True))

    # 방금 저장한거의 cuts id 번호가져오기
    cur.execute("SELECT currval(pg_get_serial_sequence('cuts', 'cut_no'))")

    # cutId 를 global 변수로 선언하고, cut_id 를 넣음
    global cutId ;
    result = cur.fetchone()

    if result is not None:
        cutId = result[0]
    else:
    # Handle the case when no result is fetched
      print("방금 생성된 컷 id 호출 오류")
      cutId= -1

    conn.commit() # 데이터베이스에 대한 변경 사항을 저장하는 역할

    # 데이터베이스에 대한 변경 사항을 저장하는 역할
    conn.commit()

    cur.close()
    conn.close()

    return render_template('first_modify.html',image_data=encoded_image,cut_no = cutId) #방금 생성한 컷 id도 html로 같이 넘겨줌


# first_modify 에서 저장할때 ( posts 네임 수정 & cut description 수정 )
# 제목 및 컷내용 저장
@app.route('/save_detail_first', methods=['POST'])
def save_detail_first():
  if request.form.get('action3') == 'S A V E': ### 이부분 다시 확인 ..
    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    # 컷 id 출력 확인
    print(cutId)
    cutNumber = str(cutId)

    # 해당컷의 post_no(컷의 post_no) 가져오기
    cur.execute("SELECT post_no FROM cuts WHERE cut_no = %s", (cutNumber,))
    result = cur.fetchone()

    if result is not None:
      postNumber = result[0]
    else:
    # Handle the case when no result is fetched
      raise ValueError("해당 컷의 post_no 호출 오류")

    conn.commit() # 데이터베이스에 대한 변경 사항을 저장하는 역할

    # 작품 id 출력 확인
    print(postNumber)
    postNumber = str(postNumber)

    #제목 불러오기
    title = request.form['title-input']
    # posts 테이블에 작품 명 업로드 update
    cur.execute("UPDATE posts SET post_name = %s WHERE post_no=%s", (title,postNumber))

    conn.commit() # 데이터베이스에 대한 변경 사항을 저장하는 역할

    #컷설명 불러오기
    cutScript = request.form['cut-input']
    print(cutScript)
    cutScript = str(cutScript)
    # cut id=***인 테이블에 컷설명 업로드
    cur.execute("UPDATE cuts SET cut_script = %s WHERE cut_no=%s", (cutScript,cutNumber))

    conn.commit()

    return render_template('index.html') # 리턴 html 수정 ==> 방금 그린거 확인할 수 있도록 gallery_ing.html로.. (보내줄 정보 다시 위에서 뿌려줘야함)


# 다음컷 저장하기 --- 현재까지 fix된 컷 다음 컷으로 db에 저장하여 next_modify로 해당 이미지 넘겨주기
@app.route('/save_image_next', methods=['POST'])
def save_imgae_next():
  # 이어그리기하는 해당 작품 id
  id = request.form.get('post_id')
  id = str(id)

  # fix된 이미지리스트 길이
  order = request.form.get('for_cut_order')
  # order = int(order)+1
  order = str(order)

  if request.form.get('select_button') == '이 컷으로 만들기':# get('name') = 'value' 형으로 적어야하는듯

    #4개중 한개 선택된 이미지의 인덱스값을 변수에 저장하는 부분
    num = request.form.get('selected_image')
    num = int(num)
    seedNum = seedList[num]
    seedNum = str(seedNum)
    encoded_image = img_str[num]

    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    #cuts 테이블에 1. post_no 가져온것(id)  + 2. 한컷 이미지 + 3. 프롬프트값 + 4.컷순서(order) + 5. 시드 + 6. 컷_fixed 업로드
    cur.execute("INSERT INTO cuts (post_no, img, cut_prompt,cut_order,cut_seed,cut_fixed) VALUES (%s,%s,%s,%s,%s,%s)", (id, encoded_image, prompt,str(order),seedNum,False))


    # cutId 를 global 변수로 선언하고, cut_id 를 넣음
    global cutId;

    # 방금 저장한 컷 id가져오기
    cur.execute("SELECT currval(pg_get_serial_sequence('cuts', 'cut_no'))")
    result = cur.fetchone()

    if result is not None:
        cutId = result[0]
        print(cutId)
    else:
    # Handle the case when no result is fetched
      print("방금 생성된 작품(post)id 호출 오류")

    conn.commit() # 데이터베이스에 대한 변경 사항을 저장하는 역할


    cur.execute("select img, cut_script, cut_order from cuts where post_no = %s and cut_fixed = true order by cut_order",(id,))

    fixed_cuts = cur.fetchall()

    img_list = []
    cut_script_list = []
    cut_order_list = []

    for fixed_cut in fixed_cuts:
      img_list.append(base64.b64decode(fixed_cut[0]))
      cut_script_list.append(fixed_cut[1])
      cut_order_list.append(fixed_cut[2])

    cur.execute("select post_name from posts where post_no = %s",(id,))
    title = cur.fetchone()

    thread_name = "th"+str(id)+str(order)

    ## 쓰레드 객체 생성
    cur.execute("select count(*) from cuts where post_no = %s and cut_order = %s", (id, order,))
    result = cur.fetchone()

    if result is not None:
        count = int(result[0])

        if count == 2:
          thread = Renewal(id, order)
          thread.start()
          print("작품 ID: ",id,"순서: ", order,"큐 길이: ", thread_queue.qsize())
        else:
          print("컷 개수 2개가 아님")
          pass
    else:
      print("컷 개수 출력 오류")


    # 저장하며 다음(next_modify)페이지로 이동하니까 이동하며 보여줄 자료 필요함
    # id값에 따른 fix된 이미지, cut_script(컷설명), 제목(title)..
    cur.close()
    conn.close()

    return render_template('next_modify.html',image_data=encoded_image, id=id, title=title, images=img_list, scripts=cut_script_list,cut_no = cutId)


@app.route('/save_detail_next', methods=['POST'])
def save_detail_next():
  if request.form.get('save_script') == 'S A V E': ### 이부분 다시 확인 ..
    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    # 컷 id 출력 확인
    print(cutId)
    cutNumber = str(cutId)

    cutScript = request.form['cut-input']
    cutScript = str(cutScript)

    # 받아온 작품 id의 다음컷 스크립트 save
    cur.execute("UPDATE cuts SET cut_script = %s WHERE cut_no=%s", (cutScript,cutNumber))

    conn.commit() # 데이터베이스에 대한 변경 사항을 저장하는 역할

    cur.close()
    conn.close()

    return render_template('index.html') # 리턴 html 수정 ==> 경쟁작 그린거 확인할수 있도록 ==> post_ing.html로.. (보내줄 정보 다시 위에서 뿌려줘야함)


# Define custom filter for Base64 encoding
@app.template_filter('b64encode')
def base64_encode(value):
    return base64.b64encode(value).decode('utf-8')


# 진행작 불러오기
@app.route('/gallery_ing')
def display_gallery_ing():
    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    cur.execute("select a.post_no, a.post_name, a.like_num, b.img from posts as a join cuts as b on a.post_no = b.post_no where a.is_done not in (5) and b.cut_order = 1 order by post_no desc limit 8 offset 0;")

    posts = cur.fetchall()

    post_no_list = []
    post_name_list = []
    like_num_list = []
    img_list = []

    for post in posts:
      post_no_list.append(post[0])
      post_name_list.append(post[1])
      like_num_list.append(post[2])
      img_list.append(base64.b64decode(post[3]))

    #print(post_no_list)
    #print(post_name_list)
    #print(like_num_list)
    #print(img_list)

    ########################################## 페이지네이션

    contents = 8 # 한 페이지에 출력되는 post 수

    cur.execute("select count(*) from posts where is_done not in (5)")

    result = cur.fetchone()
    cnt = int(result[0])

    pages = cnt//contents

    if cnt % 8 != 0:
        pages += 1

    cur.close()
    conn.close()

    return render_template('gallery_ing.html', ids=post_no_list, titles=post_name_list, images=img_list,  likes=like_num_list, pages=pages)

# 진행작 페이지네이션
@app.route('/pagination_ing', methods=['GET'])
def pagination_gallery_ing():
    cnt = request.args.get('cnt')
    cnt = int(cnt)

    contents = 8

    cnt = cnt * contents

    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    cur.execute("select a.post_no, a.post_name, a.like_num, b.img from posts as a join cuts as b on a.post_no = b.post_no where a.is_done not in (5) and b.cut_order = 1 order by post_no desc limit 8 offset %s",(cnt,))

    posts = cur.fetchall()

    post_no_list = []
    post_name_list = []
    like_num_list = []
    img_list = []

    for post in posts:
      post_no_list.append(post[0])
      post_name_list.append(post[1])
      like_num_list.append(post[2])
      img_list.append(base64.b64decode(post[3]))

    #print(post_no_list)
    #print(post_name_list)
    #print(like_num_list)
    #print(img_list)

    ########################################## 페이지네이션

    contents = 8 # 한 페이지에 출력되는 post 수

    cur.execute("select count(*) from posts where is_done not in (5)")

    result = cur.fetchone()
    cnt = int(result[0])

    pages = cnt//contents

    if cnt % 8 != 0:
        pages += 1

    cur.close()
    conn.close()

    return render_template('gallery_ing.html', ids=post_no_list, titles=post_name_list, images=img_list,  likes=like_num_list, pages=pages)


# 완성작 보여주기
@app.route('/gallery_end')
def display_gallery_end():
    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    cur.execute("select a.post_no, a.post_name, a.like_num, b.img from posts as a join cuts as b on a.post_no = b.post_no where a.is_done in (5) and b.cut_order = 1 order by post_no desc  limit 8 offset 0;")

    posts = cur.fetchall()

    post_no_list = []
    post_name_list = []
    like_num_list = []
    img_list = []

    for post in posts:
      post_no_list.append(post[0])
      post_name_list.append(post[1])
      like_num_list.append(post[2])
      img_list.append(base64.b64decode(post[3]))


    #print(post_no_list)
    #print(post_name_list)
    #print(like_num_list)
    #print(img_list)

    ########################################## 페이지네이션

    contents = 8 # 한 페이지에 출력되는 post 수

    cur.execute("select count(*) from posts where is_done not in (5)")

    result = cur.fetchone()
    cnt = int(result[0])

    pages = cnt//contents

    if cnt % 8 != 0:
        pages += 1


    cur.close()
    conn.close()

    return render_template('gallery_end.html', ids=post_no_list, titles=post_name_list, images=img_list,  likes=like_num_list, pages=pages)

# 완성작 페이지네이션
@app.route('/pagination_end', methods=['GET'])
def pagination_gallery_end():
    cnt = request.args.get('cnt')
    cnt = int(cnt)

    contents = 8

    cnt = cnt * contents

    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    cur.execute("select a.post_no, a.post_name, a.like_num, b.img from posts as a join cuts as b on a.post_no = b.post_no where a.is_done in (5) and b.cut_order = 1 order by post_no desc limit 8 offset %s",(cnt,))

    posts = cur.fetchall()

    post_no_list = []
    post_name_list = []
    like_num_list = []
    img_list = []

    for post in posts:
      post_no_list.append(post[0])
      post_name_list.append(post[1])
      like_num_list.append(post[2])
      img_list.append(base64.b64decode(post[3]))

    #print(post_no_list)
    #print(post_name_list)
    #print(like_num_list)
    #print(img_list)

    ########################################## 페이지네이션

    contents = 8 # 한 페이지에 출력되는 post 수

    cur.execute("select count(*) from posts where is_done in (5)")

    result = cur.fetchone()
    cnt = int(result[0])

    pages = cnt//contents

    if cnt % 8 != 0:
        pages += 1

    cur.close()
    conn.close()

    return render_template('gallery_end.html', ids=post_no_list, titles=post_name_list, images=img_list,  likes=like_num_list, pages=pages)


# 진행작 작품 디테일
### 경쟁작 보여주는것도 같이해야함
#fixed 안된 진행작 id 값도 보내줘야함..
@app.route('/post_ing', methods=['GET'])
def post_ing_details():
    #해당컷의 post_no 받아오기
    id = request.args.get('selected_post') # request가 get일 경우 정보를 가져올때 request.args.get / post일 경우 request.form.get
    id = int(id)
    print('이번 포스트 id 값:',id)

    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

    # fix 된 이미지 불러오기

    cur.execute("select cut_no, img, vote_num, cut_prompt, cut_order,cut_script from cuts where post_no = %s and cut_fixed = true order by cut_order",(id,))

    fixed_cuts = cur.fetchall()

    #print(fixed_cuts)

    cut_no_list = []
    img_list = []
    vote_num_list = []
    cut_prompt_list = []
    cut_order_list = []
    cut_script_list = []

    for fixed_cut in fixed_cuts:
      cut_no_list.append(fixed_cut[0])
      img_list.append(base64.b64decode(fixed_cut[1]))
      vote_num_list.append(fixed_cut[2])
      cut_prompt_list.append(fixed_cut[3])
      cut_order_list.append(fixed_cut[4])
      cut_script_list.append(fixed_cut[5])

    # 받아온 id값에 따른 제목 뜨는지 확인 완료
    cur.execute("select post_name from posts where post_no = %s",(id,))
    title = cur.fetchone()

    # cut_fixed가 false인 것 중에 order=2,3,4인 것들 리스트 따로 만들어서 보내주기
    # cut_fixed = false / order=2
    cur.execute("select img, vote_num, cut_prompt,cut_script,cut_no from cuts where post_no = %s and cut_fixed = false and cut_order = 2",(id,))

    false_cuts_2 = cur.fetchall()

    img_list2 = []
    vote_list2 = []
    prompt_list2 = []
    script_list2 = []
    cut_id_list2=[]

    for order_2 in false_cuts_2:
      img_list2.append(base64.b64decode(order_2[0]))
      vote_list2.append(order_2[1])
      prompt_list2.append(order_2[2])
      script_list2.append(order_2[3])
      cut_id_list2.append(order_2[4])

    # cut_fixed = false / order=3
    cur.execute("select img, vote_num, cut_prompt,cut_script,cut_no from cuts where post_no = %s and cut_fixed = false and cut_order = 3",(id,))

    false_cuts_3 = cur.fetchall()

    img_list3 = []
    vote_list3 = []
    prompt_list3 = []
    script_list3 = []
    cut_id_list3=[]

    for order_3 in false_cuts_3:
      img_list3.append(base64.b64decode(order_3[0]))
      vote_list3.append(order_3[1])
      prompt_list3.append(order_3[2])
      script_list3.append(order_3[3])
      cut_id_list3.append(order_3[4])

    # cut_fixed = false / order=4
    cur.execute("select img, vote_num, cut_prompt,cut_script,cut_no from cuts where post_no = %s and cut_fixed = false and cut_order = 4",(id,))

    false_cuts_4 = cur.fetchall()

    img_list4 = []
    vote_list4 = []
    prompt_list4 = []
    script_list4 = []
    cut_id_list4=[]

    for order_4 in false_cuts_4:
      img_list4.append(base64.b64decode(order_4[0]))
      vote_list4.append(order_4[1])
      prompt_list4.append(order_4[2])
      script_list4.append(order_4[3])
      cut_id_list4.append(order_4[4])

    cur.close()
    conn.close()

    deadLine = "작품을 등록해주세요!"

    ## 쓰레드 시간 출력
    i = 0
    while i < thread_queue.qsize():
      elem = thread_queue.queue[i]
      print("쓰레드 큐 객체 가져오기 elem: ", elem.post_no)
      i += 1

      if elem.post_no == str(id):
        deadLine = elem.deadLine
        print("DeadLine 출력 :", deadLine)
      else:
        print("패스")
        pass

    return render_template('post_ing.html', ids=cut_no_list, images=img_list, votes =vote_num_list, prompts=cut_prompt_list, orders=cut_order_list, title=title, id=id, scripts=cut_script_list, time = deadLine,\
                           image2=img_list2, vote2=vote_list2, prompt2=prompt_list2, script2=script_list2, cutId2= cut_id_list2, \
                           image3=img_list3, vote3=vote_list3, prompt3=prompt_list3, script3=script_list3,cutId3= cut_id_list3, \
                           image4=img_list4, vote4=vote_list4, prompt4=prompt_list4, script4=script_list4,cutId4= cut_id_list4 )

# 다음컷 그리기
@app.route('/next_drawing', methods=['POST'])
def view_page():
    generated_image = [
        'static/images/default.png',
        'static/images/default.png',
        'static/images/default.png',
        'static/images/default.png'
    ]

    id = request.form.get('selected_post') # request가 get일 경우 정보를 가져올때 request.args.get / post일 경우 request.form.get
    id = int(id)

    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

        # fix 된 이미지 불러오기

    cur.execute("select img, cut_prompt, cut_order, cut_seed from cuts where post_no = %s and cut_fixed = true order by cut_order",(id,))

    fixed_cuts = cur.fetchall()

    img_list = []
    cut_prompt_list = []
    cut_order_list = []
    cut_seed_list = []

    for fixed_cut in fixed_cuts:
      img_list.append(base64.b64decode(fixed_cut[0]))
      cut_prompt_list.append(fixed_cut[1])
      cut_order_list.append(fixed_cut[2])
      cut_seed_list.append(fixed_cut[3])

    cur.close()
    conn.close()

    return render_template('next_drawing.html', generated_image=generated_image, id=id, images=img_list, prompts=cut_prompt_list, seeds=cut_seed_list)


# 완성작 작품 디테일
@app.route('/post_end', methods=['GET'])
def post_end_details():
    id = request.args.get('selected_post') # request가 get일 경우 정보를 가져올때 request.args.get / post일 경우 request.form.get
    id = int(id)

    conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
    cur = conn.cursor()

        # fix 된 이미지 불러오기

    cur.execute("select cut_no, img, vote_num, cut_prompt, cut_order, cut_script from cuts where post_no = %s and cut_fixed = true order by cut_order",(id,))

    fixed_cuts = cur.fetchall()

    #print(fixed_cuts)

    cut_no_list = []
    img_list = []
    vote_num_list = []
    cut_prompt_list = []
    cut_order_list = []
    cut_script_list = []

    for fixed_cut in fixed_cuts:
      cut_no_list.append(fixed_cut[0])
      img_list.append(base64.b64decode(fixed_cut[1]))
      vote_num_list.append(fixed_cut[2])
      cut_prompt_list.append(fixed_cut[3])
      cut_order_list.append(fixed_cut[4])
      cut_script_list.append(fixed_cut[5])

    #print(cut_no_list)
    #print(img_list)
    #print(vote_num_list)
    #print(cut_prompt_list)
    #print(cut_order_list)
    cur.execute("select post_name from posts where post_no = %s",(id,))
    title = cur.fetchone()

    cur.close()
    conn.close()

    return render_template('post_end.html', ids=cut_no_list, images=img_list, votes =vote_num_list, prompts=cut_prompt_list, orders=cut_order_list, scripts=cut_script_list, id=id, title=title)


# 작품(post) 좋아요
@app.route('/like', methods=['POST'])
def like():
    post_id = request.form.get('post_id')
    post_id = str(post_id)
    if post_id:
        conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
        cur = conn.cursor()
        cur.execute("UPDATE posts SET like_num = like_num + 1 WHERE post_no = %s", (post_id,))
        conn.commit()
        cur.close()
        conn.close()
        print('작품:', post_id, '좋아요 성공!')
        return {'success': True}
    else:
        print('좋아요 실패!')
        return {'success': False}

# 작품(post) 좋아요취소
@app.route('/unlike', methods=['POST'])
def unlike():
    post_id = request.form.get('post_id')
    post_id = str(post_id)
    if post_id:
        conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
        cur = conn.cursor()
        cur.execute("UPDATE posts SET like_num = like_num - 1 WHERE post_no = %s", (post_id,))
        conn.commit()
        cur.close()
        conn.close()
        print('작품:', post_id, '좋아요 취소!')
        return {'success': True}
    else:
        print('취소 실패!')
        return {'success': False}


###################경쟁작 (컷) 투표

# 컷(cut) 투표하기
@app.route('/vote', methods=['POST'])
def vote():
    cut_id = request.form.get('cut_id')
    cut_id = str(cut_id)
    if cut_id:
        conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
        cur = conn.cursor()
        cur.execute("UPDATE cuts SET vote_num = vote_num + 1 WHERE cut_no = %s", (cut_id,))
        conn.commit()
        cur.close()
        conn.close()
        print('컷:', cut_id, '투표 성공!')
        return {'success': True}
    else:
        print('컷 투표 실패!')
        return {'success': False}

# 컷(cut) 투표 취소
@app.route('/unVote', methods=['POST'])
def unVote():
    cut_id = request.form.get('cut_id')
    cut_id = str(cut_id)
    if cut_id:
        conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
        cur = conn.cursor()
        cur.execute("UPDATE cuts SET vote_num = vote_num - 1 WHERE cut_no = %s", (cut_id,))
        conn.commit()
        cur.close()
        conn.close()
        print('컷:', cut_id, '투표 취소!')
        return {'success': True}
    else:
        print('취소 실패!')
        return {'success': False}


# 경쟁작 갱신 스레드 클래스
class Renewal(threading.Thread):
    def __init__(self, postID, cutOrder):
        super().__init__()
        self.post_no = postID
        self.cut_order = cutOrder
        self.now = datetime.datetime.utcnow().replace(tzinfo=pytz.utc).astimezone(korea_tz)
        self.deadLine = None

    def run(self):
        print("쓰레드 시작, 현재시각:", self.now, "해당 쓰레드 post_no :", self.post_no, "해당 쓰레드 컷 순서: ", self.cut_order)
        self.time_display()
        thread_queue.put(self)

        time.sleep(120)

        # 로직
        conn = psycopg2.connect(dbname='cnu_capstoneDB', user='root', password='root', host='svc.sel4.cloudtype.app', port=31127)
        cur = conn.cursor()

        cur.execute("select cut_no from cuts where vote_num = (select max(vote_num) from cuts where post_no = %s and cut_order = %s) and post_no =%s order by cut_no",(str(self.post_no), str(self.cut_order), str(self.post_no)))
        results = cur.fetchall()
        print(results)

        cut_no_list = []

        for result in results:
          cut_no_list.append(result[0])

        print(cut_no_list[0])


        # 좋아요 가장 많이 받은 컷을 fixed로 업데이트
        cur.execute("update cuts set cut_fixed = true where cut_no = %s",(str(cut_no_list[0]),))


        # 진행 순서 +1
        cur.execute("update posts set is_done = posts.is_done + 1 where post_no =%s",(str(self.post_no),))

        conn.commit()

        cur.close()
        conn.close()

        print("쓰레스 run() 종료 ")

        thread_queue.get()
        del self

    def time_display(self):
      # 더할 시간 (예: 1시간 30분)
      delta = datetime.timedelta(minutes=2)

      # 현재 시간에 더하기
      result_time = self.now + delta

      # 출력 형식 지정 (예: MM월 DD일 HH시 MM분)
      formatted_time = result_time.strftime("%m월 %d일 %H시 %M분")

      print("마감 시간 :",formatted_time)

      self.deadLine = formatted_time


if __name__ == "__main__":
    app.run()