def post(self, *args):
if len(args) >= 1:
name = args[0]
project = Projects(name)
for key, value in self.request.arguments.iteritems():
if key in ("git_url", "version", "build_cmd", "install_cmd"):
setattr(project, key, value[0])
project.save()
try:
if not Projects(self.get_argument('name')).exists():
raise
except Exception, e:
project = Projects()
project.name = self.get_argument('name')[0]
project.git_url = self.get_argument('git_url')[0]
for name, parm in self.request.arguments.iteritems():
if name not in ('branch', 'version'):
setattr(project, str(name), parm[0])
try:
project.add_branch(self.get_argument('branch'))
project.version(self.get_argument('branch'),
self.get_argument('version'))
project.group_name = self.get_argument('group_name')
project.save()
log.msg('Project created:', project.name)
self.write(cyclone.escape.json_encode({'status': 'ok'}))
except Exception, e:
log.err()
self.write(cyclone.escape.json_encode({'status': "fail"}))
def select_client(client_selection):
client_label['text'] = f'Client: {client_selection}'
project = Projects(workspaceId, clients.clients[client_selection])
toggle_client_selection_off()
scratch_pad.focus_set()
payload['start'] = datetime.now(tz=timezone.utc).isoformat().replace(
"+00:00", "Z")
project_name_and_id.update(
{p['name']: p['id']
for p in project.project_client})
if len(project_name_and_id) > 1:
project_frame = ProjectButtons(button_frame, borderwidth=5)
project_frame.grid(row=0, column=1, sticky=tk.NSEW)
project_buttons = [
ttk.Button(
project_frame,
text=project_item,
command=lambda project_item=project_item: select_project(
project_name_and_id[project_item], project_frame))
for project_item in project_name_and_id.keys()
]
set_button_location(project_buttons)
else:
payload['projectId'] = [
value for value in project_name_and_id.values()
][0]
def __init__(self, project):
self.project = Projects(project)
self.templates_dir = BrickConfig().get('workspace', 'template_dir')
self.git = git.Git(self.project)
self.build_system = BrickConfig().get('build', 'system')
self.build_options = BuildOptions(self.git.workdir)
self.build_container = None
self.workspace = "%s/%s" % (
BrickConfig().get('workspace', 'dir'),
self.project.name,
)
self.real_workspace = "%s/%s" % (BrickConfig().get(
'workspace', 'dir'), self.project.name)
if self.build_system == 'rpm':
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', '%{buildroot}')
elif self.build_system == 'deb' or self.build_system == None:
self.mod_install_cmd = self.project.install_cmd.replace(
'BUILDROOT', 'debian/tmp')
if not os.path.isdir(self.workspace):
os.makedirs(self.workspace)
if not os.path.isdir(os.path.join(self.workspace, 'log')):
os.makedirs(os.path.join(self.workspace, 'log'))
self.stdout = None
self.stderr = self.stdout
def __init__(self, changelog_reader):
# Administrator keyids.
# Return a *deterministic* "keyid" for the snapshot administrator.
# WARNING: Do *NOT* reuse this value anywhere else!
# It just so happens that a SHA-256 hex digest is as long as our keyid.
self.__snapshot_administrator_keyid = \
MetadataWriter.get_sha256('snapshot'.encode('utf-8'))
self.__projects_administrator_keyid = MetadataWriter.get_random_keyid()
self.__projects_subordinates_keyid = self.__projects_administrator_keyid
# Administrator keyvals.
self.__keyid_to_keyval = {
self.__snapshot_administrator_keyid:
MetadataWriter.get_random_ed25519_keyval(),
self.__projects_administrator_keyid:
MetadataWriter.get_random_ed25519_keyval()
}
# Administrator versions.
self.__snapshot_administrator_version = 0
self.__projects_administrator_version = 0
# A map of which projects subordinates are responsible for which projects.
# str (role name): {str} (set of project names)
self._projects_subordinates_to_projects = {}
# str (role name): int (version number > 0)
self._projects_subordinates_to_version = {}
# This object takes care of projects and their packages, keys, etc.
self.__projects = Projects(changelog_reader)
# Custom setup routine here.
self._setup()
def __init__(self, runtime_env, ini_file="config.ini", os=None):
self.logger = Logger(log_level=0, console_level=3)
self.sts = Settings(self.logger, runtime_env, ini_file=ini_file) # sts
self.logger.set_console_level(self.sts.debug_level)
self.logger.set_log_level(0)
self.comfun = CommonFunctions(self.logger)
if os is None:
self.os = platform.system()
if self.os == "Windows":
self.os = "w"
elif self.os == "Linux":
self.os = "l"
else:
self.os = None
# abbreviation for very often used variables, helping with identification the main modules
self.usr = Users(self) # usr
self.prj = Projects(self) # prj
self.sch = Schemas(self) # sch
self.tsk = Tasks(self) # tsk
self.que = Queue(self) # que
self.nod = SimNodes(self) # nod
self.dfn = Definitions(self) # dfn
self.sio = StorageInOut(self) # sio
# abbreviation END
self.logger.inf("SimBatch started")
def post(self, project_name):
try:
project = Projects(project_name)
git = Git(project)
git.clear_repo()
self.write(cyclone.escape.json_encode({'status': 'ok'}))
except Exception, e:
self.write(
cyclone.escape.json_encode({
'status': 'fail',
'error': str(e)
}))
def __init__(self,
username=None,
password=None,
access_token=None,
request=None):
self.request = request or PlayNicelyRequest(username, password)
self.projects = Projects(self.request)
self.milestones = Milestones(self.request)
self.items = Items(self.request)
self.users = Users(self.request)
self.echo = Echo(self.request)
def execute(cfg):
users = Users(cfg).run()
base.storage('users', users)
groups = Groups(cfg).run()
base.storage('groups', groups)
members = GroupsMembers(cfg, users, groups).run()
base.storage('groups-members', members)
projects = Projects(cfg, users['target'], groups['target']).run()
base.storage('projects', projects)
Repositories(cfg, projects['source']).run()
def delete(self, name):
log.msg("deleting project %s" % name)
try:
project = Projects(name)
git = Git(project)
git.clear_repo()
project.clear_branches()
project.delete()
self.write(
cyclone.escape.json_encode({'status': 'project deleted'}))
except Exception, e:
log.err(e)
self.write(
cyclone.escape.json_encode(
{'status': 'failed to delete %s' % str(e)}))
def get(self, name='', branch='master'):
try:
if name:
project = Projects(name)
reply = {
'name': project.name,
'branch': project.branches(),
'experimental': int(project.experimental),
'group_name': project.group_name,
'git_url': project.git_url,
'version': project.version(),
'last_tag_testing': project.last_tag(tag_type='testing'),
'last_tag_stable': project.last_tag(tag_type='stable'),
'last_tag_unstable': project.last_tag(tag_type='unstable'),
'last_commit': project.last_commit(branch)
}
else:
projects = Projects.get_all()
reply = []
for project in projects:
reply.append({
'name':
project.name,
'branch':
project.branches(),
'experimental':
int(project.experimental),
'group_name':
project.group_name,
'git_url':
project.git_url,
'version':
project.version(),
'last_tag_testing':
project.last_tag(tag_type='testing'),
'last_tag_stable':
project.last_tag(tag_type='stable'),
'last_tag_unstable':
project.last_tag(tag_type='unstable'),
'last_commit':
project.last_commit(branch)
})
self.write(cyclone.escape.json_encode(reply))
except Exception, e:
self.write(cyclone.escape.json_encode("%s No project found" % e))
def post(self, project_name):
project = Projects(project_name)
release = self.get_argument('tag')
version = self.get_argument('version')
commit = self.get_argument('commit', default=None)
reactor.callInThread(
queue.enqueue, 'build', 'builder.build_project', {
'project': project.name,
'branch': 'master',
'release': release,
'version': version,
'commit': commit,
})
self.write(
cyclone.escape.json_encode(
{'status': 'build of branch %s scheduled' % release}))
def post(self, project_name):
branch = self.get_argument('branch')
project = Projects(project_name)
if branch in project.branches():
self.write(
cyclone.escape.json_encode(
{'status': 'failed: branch already exist'}))
else:
project.add_branch(branch)
project.version(branch, '0.1')
reactor.callInThread(
queue.enqueue, 'build', 'builder.build_project', {
'project': project.name,
'branch': self.get_argument('branch'),
'release': 'experimental'
})
self.write(cyclone.escape.json_encode({'status': 'ok'}))
def execute(cfg):
# cachepath = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),'cache')
users = Users(cfg).run()
#with open(cachepath + '/users.json','r') as f:
# users = json.load(f)
groups = Groups(cfg).run()
#with open( cachepath + '/groups.json','r') as f:
# groups = json.load(f)
members = GroupsMembers(cfg, users, groups).run()
projects = Projects(cfg, users, groups).run()
# with open( cachepath + '/projects.json','r') as f:
# projects = json.load(f)
Repositories(cfg, projects).run()
def put(self, name):
project = Projects(name)
try:
for aname, arg in self.request.arguments.iteritems():
if aname in ('branch'):
branch = arg
else:
setattr(project, aname, arg[0])
json_data = json.loads(self.request.body)
if len(json_data.keys()) > 0:
for k, v in json_data.iteritems():
setattr(project, k, v)
project.save()
except Exception, e:
log.err(e)
self.finish(cyclone.escape.json_encode({'status': 'fail'}))
def display_search(project_list):
# create a list of all projects matching serch criteria, if customer name list all projects beling to naem or names
projects_tree.grid(row=1, column=0, columnspan=8)
projects_tree.delete(*projects_tree.get_children())
if type(project_list) == list:
_list = []
for project in project_list:
_list.append(
Projects(
project[1],
project[2],
project[3],
project[4],
project[5],
project[6],
project[7],
project[8],
project[9],
project[10],
project[11],
project[12],
project[13],
project[14],
project[0],
))
project_list = _list
for projects in project_list:
projects_tree.insert('',
'end',
text='project details',
values=(
Customer.get_customer_name_by_id(
projects.customer_id),
projects.project_name,
projects.primary_contact,
projects.project_reference,
projects.project_address,
projects.project_postcode,
projects.project_triage,
projects.project_id,
projects.customer_id,
))
def add_project_to_db(entry_list):
# take all the details from the page and add a new prject, make sure to check that the input is valid
# and that the project does not exsist
#get the info from the boxes, pass it to the project method
new_project = Projects(
entry_list['Customer ID'].get(),
entry_list['Project Name'].get(),
entry_list['Project Reference'].get(),
entry_list['Project Address'].get(),
entry_list['Project Postcode'].get(),
entry_list['Primary Contact'].get(),
entry_list['Project Type'].get(),
entry_list['Project Price Approx'].get(),
'',
entry_list['Project Expected Profit'].get(),
'',
entry_list['Project Triage'].get(),
entry_list['Project Lead MES'].get(),
'',
'',
)
# print(new_project)
new_project.save_to_db()
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
import logging
import os
import time
from optparse import OptionParser
from jsonbackend import JsonBackend
from projects import Projects
projects = Projects()
def init_logging():
logfile = 'builder.log'
if os.path.isfile(logfile):
os.remove(logfile)
logging.basicConfig(filename=logfile, level=logging.DEBUG)
logger = logging.getLogger('')
console = logging.StreamHandler()
console.setLevel(logging.INFO)
logger.addHandler(console)
def post(self, project_name):
project = Projects(project_name)
builder = Builder(project_name)
builder.build_project()
def delete(self, project_name):
project = Projects(project_name)
branch = self.get_argument('branch')
project.remove_branch(branch)
self.write(cyclone.escape.json_encode({'status': 'ok'}))
def get(self, project_name):
project = Projects(project_name)
git = Git(project)
branches = git.branches(remote=True)
self.write(cyclone.escape.json_encode({'branches': branches}))
import datetime
import calendar
import tkinter as tk
from tkinter import ttk
import hud as Hud
from customer import Customer
from database import Database
from projects import Projects
from tasks import Tasks
from tkcalendar import Calendar
from tkcalendar import DateEntry
current_customer = Customer('', '', '', '', '', '', '', '')
current_project = Projects('', '', '', '', '', '', '', '', '', '', '', '', '',
'', '')
current_task = Tasks('', '', '', '', '', '', '', '')
task_frame_count = []
LARGE_FONT = ('Verdaba', 12)
def convert_date_postgres(date_to_conv, I_or_O):
# if I prepare for input, if O prepare for output
if I_or_O.lower() == 'i':
year_to = date_to_conv[6:10]
month_to = date_to_conv[3:5]
day_to = date_to_conv[0:2]
iso = f'{year_to}-{month_to}-{day_to}'
return iso
if I_or_O.lower() == 'o':
usage()
try:
srcSys = opts['-s']
dstSys = opts['-d']
grpNam = opts['-g']
except KeyError:
usage()
# create a group itself
grp = Groups()
try:
srcGid = grp.by_name(srcSys, grpNam)['id']
except KeyError:
usage("Group with name '%s' doesn't exist in the source system" % grpNam)
dstGid = grp.add(dstSys, grpNam)['id']
# add members to the group
add_members(grp, srcGid, dstGid)
# copy projects with their members from the source group to the destination one
prj = Projects()
for p in prj.by_namespace(srcSys, srcGid):
add_members(prj, p['id'], prj.add(dstSys, p['name'], namespace_id = dstGid, **filter_dict(p,
'description',
'issues_enabled',
'merge_requests_enabled',
'wiki_enabled',
'snippets_enabled',
'visibility_level'))['id'])
