mirror of https://github.com/zeldaret/tp.git
229 lines
6.7 KiB
Python
229 lines
6.7 KiB
Python
from .repository import RepoInfo
|
|
from .graphql import GraphQLClient
|
|
from .util import *
|
|
from .state import *
|
|
from logger import LOG
|
|
from dataclasses import dataclass
|
|
from typing import Optional
|
|
|
|
import yaml, sys
|
|
|
|
@dataclass
|
|
class Label:
|
|
@staticmethod
|
|
def get_all_from_yaml(data):
|
|
ret_labels = []
|
|
sub_labels = []
|
|
|
|
for d in data:
|
|
sub_labels = get_sub_labels(d)
|
|
|
|
for label in sub_labels:
|
|
ret_label = Label(name=label)
|
|
ret_labels.append(ret_label)
|
|
|
|
title_label = Label(data=d)
|
|
ret_labels.append(title_label)
|
|
|
|
return ret_labels
|
|
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, Label):
|
|
return self.name == other.name and self.id == other.id
|
|
return False
|
|
|
|
def __hash__(self):
|
|
return hash((self.name, self.id))
|
|
|
|
def __init__(self,data=None,id=None,name=None):
|
|
if data is not None:
|
|
project_data = data.get('project', {})
|
|
self.yaml_ctor(project_data)
|
|
else:
|
|
self.id = id
|
|
self.name = name
|
|
|
|
def yaml_ctor(self,project_data):
|
|
self.id = None
|
|
self.name = project_data.get('title', 'MISSING_TITLE')
|
|
|
|
@staticmethod
|
|
def delete_all():
|
|
LOG.debug(f'Deleting all labels in {RepoInfo.owner.name}/{RepoInfo.name}')
|
|
|
|
label_state = StateFile.data["labels"]
|
|
if label_state is not None and len(StateFile.data) > 0:
|
|
for label in label_state.copy():
|
|
Label(
|
|
id=label["id"],
|
|
name=label["name"]
|
|
).delete()
|
|
else:
|
|
LOG.warning(f'No labels found in state file, nothing to delete.')
|
|
return
|
|
|
|
@staticmethod
|
|
def get_all_from_github() -> list['Label']:
|
|
LOG.debug(f'Fetch all current labels for {RepoInfo.owner.name}/{RepoInfo.name}')
|
|
query = '''
|
|
query ($owner: String!, $repo: String!) {
|
|
repository(owner: $owner, name: $repo) {
|
|
labels(first: 100) {
|
|
nodes {
|
|
name
|
|
id
|
|
}
|
|
}
|
|
}
|
|
}
|
|
'''
|
|
|
|
variables = {
|
|
"owner": RepoInfo.owner.name,
|
|
"repo": RepoInfo.name
|
|
}
|
|
|
|
data = GraphQLClient.get_instance().make_request(query, variables)
|
|
if data:
|
|
labels = data['data']['repository']['labels']['nodes']
|
|
LOG.debug(f'Labels retrieved: {labels}')
|
|
return [
|
|
Label(
|
|
id=label["id"],
|
|
name=label["name"]
|
|
) for label in labels
|
|
]
|
|
else:
|
|
LOG.warning(f'No labels found in {RepoInfo.owner.name}/{RepoInfo.name}')
|
|
return []
|
|
|
|
@staticmethod
|
|
def get_id_by_name(label_name: str):
|
|
LOG.debug(f'Fetch label ID for label {label_name} in {RepoInfo.owner.name}/{RepoInfo.name}')
|
|
query = '''
|
|
query ($owner: String!, $repo: String!) {
|
|
repository(owner: $owner, name: $repo) {
|
|
labels(first: 100) {
|
|
nodes {
|
|
name
|
|
id
|
|
}
|
|
}
|
|
}
|
|
}
|
|
'''
|
|
|
|
variables = {
|
|
"owner": RepoInfo.owner.name,
|
|
"repo": RepoInfo.name
|
|
}
|
|
|
|
data = GraphQLClient.get_instance().make_request(query, variables)
|
|
if data:
|
|
labels = data['data']['repository']['labels']['nodes']
|
|
for label in labels:
|
|
if label['name'] == label_name:
|
|
LOG.debug(f'Label ID for {label_name} retrieved: {label["id"]}')
|
|
return label['id']
|
|
|
|
LOG.warning(f'Label {label_name} not found in {RepoInfo.owner.name}/{RepoInfo.name}')
|
|
return None
|
|
|
|
def check_and_create(self) -> None:
|
|
labels = StateFile.data.get('labels')
|
|
|
|
if labels is None:
|
|
label_dict = {}
|
|
else:
|
|
label_dict = {label['name']: label for label in labels}
|
|
|
|
if self.name in label_dict:
|
|
LOG.info(f"Label {self.name} already setup!")
|
|
self.id = label_dict[self.name]["id"]
|
|
self.name = label_dict[self.name]["name"]
|
|
else:
|
|
LOG.debug(f'Creating missing label {self.name}.')
|
|
self.create()
|
|
|
|
|
|
def create(self) -> None:
|
|
LOG.debug(f'Creating issue label: {self.name}')
|
|
|
|
mutation = '''
|
|
mutation ($repoId: ID!, $labelName: String!, $color: String!) {
|
|
createLabel(input: { name: $labelName, repositoryId: $repoId, color: $color }) {
|
|
label {
|
|
name
|
|
id
|
|
}
|
|
}
|
|
}
|
|
'''
|
|
|
|
variables = {
|
|
"repoId": RepoInfo.id,
|
|
"labelName": self.name,
|
|
"color": generate_random_rgb_hex()
|
|
}
|
|
|
|
|
|
data = GraphQLClient.get_instance().make_request(mutation, variables)
|
|
if data:
|
|
LOG.debug(f'Create label data: {data}')
|
|
self.id = data['data']['createLabel']['label']['id']
|
|
self.write_state_to_file()
|
|
LOG.info(f"Successfully created label '{self.name} with ID {self.id}'!")
|
|
else:
|
|
LOG.error(f"Failed to create label {self.name}")
|
|
sys.exit(1)
|
|
|
|
def delete(self) -> None:
|
|
query = '''
|
|
mutation ($labelId: ID!) {
|
|
deleteLabel(input: {
|
|
id: $labelId
|
|
}) {
|
|
clientMutationId
|
|
}
|
|
}
|
|
'''
|
|
|
|
variables = {
|
|
"labelId": self.id
|
|
}
|
|
|
|
data = GraphQLClient.get_instance().make_request(query, variables)
|
|
if data:
|
|
self.write_state_to_file(delete=True)
|
|
LOG.info(f'Successfully deleted label {self.name}')
|
|
else:
|
|
LOG.error(f'Failed to delete label {self.name}')
|
|
|
|
def write_state_to_file(self, delete: bool = False):
|
|
state = {
|
|
"id": self.id,
|
|
"name": self.name
|
|
}
|
|
|
|
curr_state_labels = StateFile.data.get('labels',None)
|
|
|
|
if curr_state_labels is not None:
|
|
|
|
for i, label in enumerate(StateFile.data['labels']):
|
|
if label['id'] == self.id:
|
|
if delete:
|
|
del StateFile.data['labels'][i]
|
|
break
|
|
else:
|
|
StateFile.data['labels'][i] = state
|
|
break
|
|
else:
|
|
StateFile.data['labels'].append((state))
|
|
else:
|
|
StateFile.data['labels'] = [state]
|
|
|
|
|
|
with open("tools/pjstate.yml", 'w') as f:
|
|
yaml.safe_dump(StateFile.data, f)
|