def main(argv=sys.argv):
if len(argv) != 3:
usage(argv)
config_uri = argv[1]
svn_csv = argv[2]
setup_logging(config_uri)
settings = get_appsettings(config_uri, name='dashboard')
engine = engine_from_config(settings, 'sa.dashboard.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
Base.metadata.create_all()
with transaction.manager:
session = DBSession()
with open(svn_csv, 'rb') as csvfile:
reader = csv.reader(csvfile)
for project_id, svn_repo in reader:
svn_repo = svn_repo.strip()
project_id = project_id.strip()
project = session.query(Project).get(project_id)
app = Application(name='SVN',
project_id=project_id,
application_type=SVN,
svn_name=svn_repo)
project.add_application(app)
print 'Creating svn app [%s] for project [%s]' % (svn_repo, project_id)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
env = bootstrap('%s#dashboard'% config_uri)
settings = env.get('registry').settings
engine = engine_from_config(settings, 'sa.dashboard.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
Base.metadata.create_all()
def generate_password():
return base64.urlsafe_b64encode(os.urandom(30))
with transaction.manager:
session = DBSession()
users = [
add_user(session, u'*****@*****.**', fullname='Administrator', password='******'),
]
role_admin = add_role(session, 'administrator')
role_admin.users.append(users[0])
add_role(session, 'external_developer')
add_role(session, 'internal_developer')
add_role(session, 'secretary')
add_role(session, 'customer')
add_role(session, 'project_manager')
session.add(GlobalConfig(id=1))
def __call__(self, parser, namespace, values, option_string):
super(QualityRaw, self).__call__(parser, namespace, values, option_string)
session = DBSession()
with open(namespace.filename, 'wb') as ofile:
writer = csv.writer(ofile, dialect='excel')
writer.writerow(['CR ID', 'Customer', 'Duration in days'])
for cr in session.query(CustomerRequest.id,
CustomerRequest.project_id,
Project.customer_id,
Trac.trac_name).\
outerjoin(Project,
CustomerRequest.project_id == Project.id).\
outerjoin(Trac,
Project.id==Trac.project_id).distinct():
tickets, Ticket, TicketCustom = tickets_for_cr(self.metadata, session, cr.trac_name, cr.id)
tids = [t.id for t in tickets]
if not tids:
continue
entries = session.query(TimeEntry)\
.filter_by(project_id=cr.project_id)\
.filter(TimeEntry.ticket.in_(tids))\
.filter(extract('year', TimeEntry.date) == namespace.year)
if entries.count():
hours = timedelta_as_work_days(sum([a.hours for a in entries], timedelta()))
writer.writerow([cr.id, cr.customer_id, hours])
def __call__(self, parser, namespace, values, option_string):
super(QualityTicket, self).__call__(parser, namespace, values, option_string)
session = DBSession()
with open(namespace.filename, 'wb') as ofile:
writer = csv.writer(ofile, dialect='excel')
writer.writerow(['Ticket ID', 'Customer',
'Ticket creation year',
'Ticket creation month',
'Ticket creation day',
'Ticket completion year',
'Ticket completion moneth',
'Ticket completion day',
'Ticket state', 'Ticket last owner', 'Ticket types',
'Ticket opened by customer', 'Problem nature'])
for pr in session.query(Project.customer_id, Project.id, Trac.trac_name)\
.outerjoin(Trac, Project.id==Trac.project_id)\
.outerjoin(TimeEntry, TimeEntry.project_id==Project.id)\
.filter(TimeEntry.project_id==Project.id)\
.filter(extract('year', TimeEntry.date) == namespace.year).distinct():
tickets, Ticket, TicketCustom = tickets_for_cr(self.metadata, session, pr.trac_name)
tickets_in_year = session.query(Ticket)\
.outerjoin(TimeEntry,
and_(TimeEntry.project_id==pr.id,
TimeEntry.ticket==Ticket.id))\
.filter(extract('year', TimeEntry.date) == namespace.year).distinct()
for ticket in tickets_in_year:
last_status = ticket.last_history('status', namespace.year)
close_date = ticket.close_date
all_types = set([])
for h in ticket.history:
if h.field == 'type':
all_types.update([h.oldvalue])
all_types.update([ticket.type])
all_types = '|'.join(all_types).encode('utf8','ignore')
writer.writerow(
[ticket.id, pr.customer_id,
ticket.date.strftime('%Y'),
ticket.date.strftime('%m'),
ticket.date.strftime('%d'),
close_date and close_date.strftime('%Y') or '',
close_date and close_date.strftime('%m') or '',
close_date and close_date.strftime('%d') or '',
last_status, ticket.owner, all_types,
ticket.open_by_customer and ticket.open_by_customer.unicode_value or '',
ticket.issue_type and ticket.issue_type.unicode_value or ''])
def unique(value, field=None):
"""Successful if value is unique"""
msg = _('Broken ${value}', mapping={'value': value})
if not field:
raise ValidationError(msg)
session = DBSession()
filters = {}
filters[field._column_name] = value
records = session.query(field.model.__class__).filter_by(**filters)
if records.count() > 0 and records.one() != field.model:
msg = _("${value} already exists! Field '${field_column_name}' should be unique!",
mapping={'value': value, 'field_column_name': field._column_name})
raise ValidationError(msg)
return value
def main(argv=sys.argv):
if len(argv) > 3:
usage(argv)
if len(argv) == 3:
use_small = True
else:
use_small = False
config_uri = argv[1]
setup_logging(config_uri)
env = bootstrap('%s#dashboard'% config_uri)
settings = env.get('registry').settings
engine = engine_from_config(settings, 'sa.dashboard.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
Base.metadata.create_all()
with transaction.manager:
random.seed(42)
session = DBSession()
session.add(GlobalConfig(id=1))
users = [
add_user(session, u'*****@*****.**', fullname='John Smith'),
add_user(session, u'*****@*****.**', fullname='Mr. Customer'),
]
role_admin = add_role(session, 'administrator')
role_admin.users.append(users[0])
add_role(session, 'external_developer')
add_role(session, 'internal_developer')
add_role(session, 'secretary')
role_customer = add_role(session, 'customer')
role_customer.users.append(users[1])
add_role(session, 'project_manager')
if use_small:
small_dummies(session,users,settings)
else:
full_dummies(session,users,settings)
def __call__(self, parser, namespace, values, option_string):
super(Quality, self).__init__(parser, namespace, values, option_string)
self.namespace = namespace
config_uri = namespace.configuration
setup_logging(config_uri)
settings = get_appsettings(config_uri, name='dashboard')
engine = engine_from_config(settings, 'sa.dashboard.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
Base.metadata.create_all()
self.metadata = MetaData(engine)
#if not namespace.google and not namespace.filename:
# raise argparse.ArgumentTypeError(u'You need to pass filename or google.')
configuration = {}
tmp = tempfile.NamedTemporaryFile(suffix='.csv')
namespace.filename = tmp.name
tmp.close()
configuration['filename'] = namespace.filename
print 'Creating file %s' % namespace.filename
setattr(namespace, option_string.strip('--'), configuration)
def __call__(self, parser, namespace, values, option_string):
super(QualityCR, self).__call__(parser, namespace, values, option_string)
session = DBSession()
with open(namespace.filename, 'wb') as ofile:
writer = csv.writer(ofile, dialect='excel')
writer.writerow(['CR ID', 'Customer', 'CR state',
'Estimation in days', 'TE Duration in days',
'TE sistem/install in days'])
for cr in session.query(CustomerRequest.id,
CustomerRequest.workflow_state,
CustomerRequest.project_id,
Project.customer_id,
Trac.trac_name).\
outerjoin(Project,
CustomerRequest.project_id == Project.id).\
outerjoin(Trac,
Project.id==Trac.project_id).distinct():
tickets, Ticket, TicketCustom = tickets_for_cr(self.metadata,
session, cr.trac_name, cr.id)
tids = [t.id for t in tickets]
if not tids:
continue
estimations = sum([a.days for a in \
session.query(Estimation.days)\
.filter_by(customer_request_id=cr.id)])
entries = session.query(TimeEntry)\
.filter_by(project_id=cr.project_id)\
.filter(TimeEntry.ticket.in_(tids))\
.filter(extract('year', TimeEntry.date) == namespace.year)
if entries.count():
total_hours = timedelta_as_work_days(sum([a.hours for a in entries], timedelta()))
only_dev = entries.filter(or_(TimeEntry.description.ilike('%install%'),
TimeEntry.description.ilike('%sistem%')))
only_dev_hours = timedelta_as_work_days(sum([a.hours for a in only_dev], timedelta()))
writer.writerow([cr.id, cr.customer_id, cr.workflow_state, estimations, total_hours, only_dev_hours])
def __call__(self, parser, namespace, values, option_string):
super(QualityProject, self).__call__(parser, namespace, values, option_string)
session = DBSession()
with open(namespace.filename, 'wb') as ofile:
writer = csv.writer(ofile, dialect='excel')
writer.writerow(['Project ID', 'Customer', 'Project creation year',
'Project creation month', 'Project creation day',
'Project completion year', 'Project completion month',
'Project completion day'])
for project in session.query(Project.id, Project.completion_date,
Project.customer_id, Project.creation_date)\
.outerjoin(TimeEntry, TimeEntry.project_id==Project.id)\
.filter(extract('year', TimeEntry.date) == namespace.year)\
.distinct():
writer.writerow([project.id, project.customer_id,
project.creation_date.strftime('%Y'),
project.creation_date.strftime('%m'),
project.creation_date.strftime('%d'),
project.completion_date and project.completion_date.strftime('%Y') or '',
project.completion_date and project.completion_date.strftime('%m') or '',
project.completion_date and project.completion_date.strftime('%d') or '',
])
def update_time_entries():
session = DBSession()
tracs = {}
time_entries = session.query(TimeEntry)
for tp in time_entries:
trac = list(tp.project.tracs)[0]
tracs.setdefault(trac.trac_name, [])
if not tp.ticket:
print "TimeEntry %s has no ticket" % tp.id
continue
tracs[trac.trac_name].append((tp.id, tp.ticket))
ticket_vs_crs = """SELECT value AS cr_id, '%(tp_id)s' AS tp_id FROM "trac_%(trac)s".ticket_custom WHERE name='customerrequest' AND ticket=%(ticket)s"""
splitted_tracs = split_dict_equally(tracs)
for split in splitted_tracs:
queries = []
for trac_id, opts in split.items():
for opt in opts:
queries.append(ticket_vs_crs % {'trac': trac_id,
'tp_id': opt[0],
'ticket': opt[1]})
sql = '\nUNION '.join(queries)
sql += ';'
for trac in DBSession().execute(sql).fetchall():
cr = session.query(CustomerRequest).get(trac.cr_id)
if not cr:
continue
contract = cr.contract
if not contract:
continue
tp = session.query(TimeEntry).get(trac.tp_id)
if not tp:
continue
tp.contract_id = contract.id
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
env = bootstrap('%s#dashboard'% config_uri)
settings = env.get('registry').settings
engine = engine_from_config(settings, 'sa.dashboard.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
google_opts = argv[2:]
try:
google_user = google_opts.pop(0)
except IndexError:
google_user = raw_input('Google Spreadsheet User: '******'Google Spreadsheet ID: ')
google_password = getpass.getpass("Google Spreadsheet Password: ")
gc = gspread.login(google_user, google_password)
sht = gc.open_by_key(spreadsheet_key)
worksheet = sht.get_worksheet(0)
crs = worksheet.get_all_records()
contracts = {}
for row in crs:
if not row['titolocommessa']:
continue
contract_uid = '%s_%s_%s' % (row['project_name'],
row['titolocommessa'],
row['customer_id'])
contracts.setdefault(contract_uid, {'crs': []})
contracts[contract_uid]['titolocommessa'] = row['titolocommessa']
contracts[contract_uid]['nrcontratto'] = row['nrcontratto']
contracts[contract_uid]['gg'] = row['gg'] or 0
contracts[contract_uid]['amount'] = row['amount'] or 0
contracts[contract_uid]['crs'].append(row['cr_id'])
contracts[contract_uid]['stato'] = map_state(row['stato'])
# now we have a structure:
# contracts['ContractUID'] = {'crs': ['customer_request_id_1',
# 'customer_request_id_2'],
# 'gg': '12'}
with transaction.manager:
session = DBSession()
for contract_uid, opts in contracts.items():
crs = [session.query(CustomerRequest).get(a) for a in opts['crs']]
crs = [a for a in crs if a]
if not crs:
continue
contract = crs[0].contract
if not contract:
contract = Contract(name=opts['titolocommessa'])
contract.days = opts['gg']
contract.ammount = opts['amount']
contract.contract_number = opts['nrcontratto']
contract.workflow_state = opts['stato']
for cr in crs:
if not cr:
continue
cr.contract = contract
contract.project_id = cr.project_id
update_time_entries()
def initialize_sql(config=None, engine=None):
if not engine:
engine = engine_from_config(config.registry.settings, 'sa.dashboard.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
