def __init__(self):
logging.debug("start the ResourceStatus_DataService()")
self.userdao = User_DAO()
self.incidao = Incident_DAO()
self.resreqdao = ResourceRequest_DAO()
self.resdao = Resource_DAO()
self.repairResourcedao = RepairResource_DAO()
def __init__(self):
logging.debug("start the Search_Result_DataService()")
self.res_dao = Resource_DAO()
self.inci_dao = Incident_DAO()
self.user_dao = User_DAO()
self.res_request_dao = ResourceRequest_DAO()
self.repair_resource_dao = RepairResource_DAO()
self.incidentEntry = ""
self.username = ""
def test_submit_form_for_new_resource(self):
ard = Add_Resource_DataService("james")
rd = Resource_DAO()
print "before: " + str(rd.get_count_as_int())
ard.submit_form_for_new_resource("test", "testmodel", 1.1, 2.2, 3.5, 2,
"hour", [3, 4, 5], ["aaa", "bbb"])
print "after : " + str(rd.get_count_as_int())
def __init__(self, username):
logging.info("start the Add_Resource_DataService")
self.resource_dao = Resource_DAO()
self.new_generated_resource_id = self.resource_dao.get_count_as_int() + 100000
self.capability_dao = Capability_DAO(self.new_generated_resource_id)
self.additional_esf_dao = Additional_DAO(self.new_generated_resource_id)
self.username = username
self.esf_list_dao = ESF_DAO()
self.usertype_dao = UserType_DAO()
self.costunitdao = CostUnit_DAO()
def test_insert_record(self):
rsd = Resource_DAO()
count_for_test = run_sql_string_statement(
"select count(*) from Resource")
count = int(count_for_test[0][0])
rsd.insert_resource(count + 1, "123Name", "dummy", "available", 14.56,
33.12, "james", 120.4, 3, "hour", "tom",
"2015-03-02", "2016-07-03")
def test_more(self):
srd = Search_Result_DataService()
resd = Resource_DAO()
rep = RepairResource_DAO()
reqeust = ResourceRequest_DAO()
count_for_test = run_sql_string_statement(
"select count(*) from Resource")
count = int(count_for_test[0][0])
a = count + 1
b = count + 2
resd.insert_resource(a, "123Name", "dummy", "not available", 14.56,
33.12, "james", 120.4, 3, "hour", "tom",
"2015-03-02", "2016-07-03")
resd.insert_resource(b, "123Name", "dummy", "in repair", 14.56, 33.12,
"james", 120.4, 3, "hour", "tom", "2015-03-02",
"2016-07-03")
rep.insert_records(b,
rep.get_count() + 1, "james", "2015-03-02",
"2016-07-03")
reqeust.insert_record(1, reqeust.get_count() + 1, "2015-03-02", a)
ma = srd.populate_table_data("a", "2# aaa", 1000000, "(6) testinci")
assert isinstance(ma, list)
print ma
class ActionButton_Dataservice():
def __init__(self):
logging.info("start the ActionButton_Dataservice")
self.resource_request_dao = ResourceRequest_DAO()
self.repair_resource_dao = RepairResource_DAO()
self.resource_dao = Resource_DAO()
def request_function(self, resId, expDate, incid):
assert isinstance(resId, int)
assert isinstance(expDate, str)
assert isinstance(incid, int)
new_id = int(self.resource_request_dao.get_count()) + 1000
self.resource_request_dao.insert_record(incid, new_id, expDate, resId)
def repair_function(self, resId, username, duration):
assert isinstance(resId, int)
assert isinstance(username, str)
assert isinstance(duration, int)
repId = int(self.repair_resource_dao.get_count()) + 1
currentStatus = self.resource_dao.get_resource_status_by_resourceId(
resId)
if currentStatus == "available":
start = datetime.now()
end = start + timedelta(days=duration)
sd = datetime.strftime(start, "%Y-%m-%d")
ed = datetime.strftime(end, "%Y-%m-%d")
self.resource_dao.update_status_resource_id(resId, "in repair")
self.repair_resource_dao.insert_records(resId, repId, username, sd,
ed)
if currentStatus == "not available":
start = self.resource_dao.get_duedate_by_resourceId(resId)
sd = datetime.strptime(start, "%Y-%m-%d")
end = sd + timedelta(days=duration)
sd = datetime.strftime(sd, "%Y-%m-%d")
ed = datetime.strftime(end, "%Y-%m-%d")
self.repair_resource_dao.insert_records(resId, repId, username, sd,
ed)
def deploy_function(self, incid, resid, username):
assert isinstance(incid, int)
assert isinstance(resid, int)
assert isinstance(username, str)
duedate = self.resource_request_dao.get_expectedreturndate_by_resIdAndInciId(
resid, incid)
start = datetime.now()
sd = datetime.strftime(start, "%Y-%m-%d")
logging.info(sd)
end = start + timedelta(days=22)
ed = datetime.strftime(end, "%Y-%m-%d")
self.resource_dao.update_all_resource_id("not available", sd, ed,
username, resid)
self.resource_request_dao.delete_by_resIdAndInciId(resid, incid)
def get_resource_lists_by_keyword_esf(self):
rsd = Resource_DAO()
result = rsd.get_resource_lists_by_keyword_esf("gen")
print result
def test_get_resource_lists_by_keyword_capabilities(self):
rsd = Resource_DAO()
result = rsd.get_resource_lists_by_keyword_capabilities("cap")
print result
def test_get_resourceId_lists_by_keyword_model_or_name(self):
rsd = Resource_DAO()
result = rsd.get_resourceId_lists_by_keyword_model_or_name("test")
print result
def test_get_record_by_resId(self):
rsd = Resource_DAO()
result = rsd.get_resource_record_by_resourceId(4)
for row in result:
print row
def test_get_count(self):
rsd = Resource_DAO()
result = rsd.get_count_as_int()
print result
assert isinstance(result, int)
def test_get_record_by_owner(self):
rsd = Resource_DAO()
result = rsd.get_resource_record_by_owner("james")
for row in result:
print row
class Add_Resource_DataService():
def __init__(self, username):
logging.info("start the Add_Resource_DataService")
self.resource_dao = Resource_DAO()
self.new_generated_resource_id = self.resource_dao.get_count_as_int() + 100000
self.capability_dao = Capability_DAO(self.new_generated_resource_id)
self.additional_esf_dao = Additional_DAO(self.new_generated_resource_id)
self.username = username
self.esf_list_dao = ESF_DAO()
self.usertype_dao = UserType_DAO()
self.costunitdao = CostUnit_DAO()
def get_new_generated_resource_id(self):
'''
@rtype: int
'''
return self.new_generated_resource_id
def submit_form_for_new_resource(self, ResourceName, model, Latitude, Longitude,
CostPerValue, EsfID, CostUnit, additionalESFList, capabilitiesList):
'''
@rtype: bool
'''
assert isinstance(self.new_generated_resource_id, int)
assert isinstance(ResourceName, str)
assert isinstance(model, str)
# assert isinstance(CurrentStatus, str)
assert isinstance(Latitude, float)
assert isinstance(Longitude, float)
# assert isinstance(Owner, str)
assert isinstance(CostPerValue, float)
assert isinstance(EsfID, int)
assert isinstance(CostUnit, str)
# assert isinstance(CurrentUser, str)
# assert isinstance(StartDate, str)
# assert isinstance(DueDate, str)
assert isinstance(additionalESFList, list)
assert isinstance(capabilitiesList, list)
STATUS = ["available", "not available", "in repair"]
# insert into the resource table
self.resource_dao.insert_resource(self.new_generated_resource_id,
ResourceName,
model,
STATUS[0],
Latitude,
Longitude,
self.username,
CostPerValue,
EsfID,
CostUnit,
self.username,
time.strftime("%y-%m-%d"),
time.strftime("%y-%m-%d"))
# insert into the additional esf table
add_esf_dao = Additional_DAO(self.new_generated_resource_id)
add_esf_dao.insert_additional_esf_list(additionalESFList)
# insert into the cap table
capdao = Capability_DAO(self.new_generated_resource_id)
capdao.insert_capability(capabilitiesList)
def populate_owner_title(self):
'''
@rtype: str
'''
usertype = self.usertype_dao.get_user_type_by_username(self.username)
MUNICIPALITIES = "municipalities"
GOVERNMENT_AGENCIES = "government_agencies"
COMPANIES = "companies"
INDIVIDUALS = "individuals"
if usertype == MUNICIPALITIES:
return self.usertype_dao.get_title_info_from_municipalities(self.username)
if usertype == GOVERNMENT_AGENCIES:
return self.usertype_dao.get_title_info_from_government(self.username)
if usertype == COMPANIES:
return self.usertype_dao.get_title_info_from_company(self.username)
if usertype == INDIVIDUALS:
return self.usertype_dao.get_title_info_from_individuals(self.username)[0]
return ""
def populate_esf_list(self):
'''
@rtype: dict
'''
return self.esf_list_dao.get_all_esf_records()
def populate_costunit_list(self):
return self.costunitdao.get_all_CostUnits()
def get_all_resid(self):
rsd = Resource_DAO()
result = rsd.get_all_resource_id()
rsd.update_status_resource_id(3, "in repair")
print result
def get_resource_list(self):
rsd = Resource_DAO()
result = rsd.get_resource_costtext_by_resourceId(3)
print result
class ResourceStatus_DataService():
def __init__(self):
logging.debug("start the ResourceStatus_DataService()")
self.userdao = User_DAO()
self.incidao = Incident_DAO()
self.resreqdao = ResourceRequest_DAO()
self.resdao = Resource_DAO()
self.repairResourcedao = RepairResource_DAO()
def populate_res_in_use_tabledata(self, username):
assert isinstance(username, str)
sql = "SELECT ResourceID, ResourceName, owner, startDate, CurrentUser FROM Resource WHERE ResourceID in (SELECT ResourceID FROM Resource WHERE CurrentUser ='******');"
sql = sql.format(username)
result = run_sql_string_statement(sql)
fr = list()
if len(result) == 0 or len(result[0]) == 0:
return fr
for row in result:
tmp = list()
tmp.append(row[0])
tmp.append(row[1])
tmp.append(self.userdao.get_nameinfo_by_username(row[2]))
tmp.append(str(row[3]))
tmp.append(self.userdao.get_nameinfo_by_username(row[4]))
fr.append(tmp)
return fr
def return_button(self, resId):
assert isinstance(resId, int)
sql = "UPDATE Resource SET startDate =NULL, DueDate = NULL, CurrentUser = NULL, CurrentStatus ='available' WHERE ResourceID = {0};"
sql = sql.format(resId)
result = run_sql_string_statement(sql)
def res_request_by_username(self, username):
assert isinstance(username, str)
finalresult = list()
sql = "SELECT ResourceID, IncidentID FROM ResourceRequest WHERE IncidentID in (SELECT IncidentID FROM Incident WHERE Incident.username ='******');"
sql = sql.format(username)
temp_result = run_sql_string_statement(sql)
if len(temp_result) == 0 or len(temp_result[0]) == 0:
return finalresult
templist = list()
for row in temp_result:
rowtemp = list()
resid = int(row[0])
incid = int(row[1])
sql = "SELECT ResourceName, Owner, DueDate FROM Resource WHERE ResourceID = {0};".format(resid)
t1 = run_sql_string_statement(sql)
if len(t1) == 0 or len(t1[0]) == 0:
rowtemp.append(resid)
rowtemp.append("")
rowtemp.append("")
rowtemp.append("")
rowtemp.append("")
rowtemp.append("")
else:
rowtemp.append(resid)
rowtemp.append(t1[0][0])
rowtemp.append(self.incidao.get_incident_description_by_incidentId(incid))
rowtemp.append(self.userdao.get_nameinfo_by_username(t1[0][1]))
rowtemp.append(str(t1[0][2]))
rowtemp.append(incid)
finalresult.append(rowtemp)
return finalresult
def cancel_button(self, resid, incid):
assert isinstance(resid, int)
assert isinstance(incid, int)
self.resreqdao.delete_by_resIdAndInciId(resid, incid)
def request_received_me(self, username):
assert isinstance(username, str)
finalresult = list()
sql = "SELECT ResourceID, RequestID, ExpectedReturnDate, IncidentID FROM ResourceRequest WHERE ResourceID in (SELECT ResourceID from Resource WHERE Resource.Owner ='{0}');"
sql = sql.format(username)
temp_result = run_sql_string_statement(sql)
if len(temp_result) == 0 or len(temp_result[0]) == 0:
return finalresult
templist = list()
for row in temp_result:
resid = row[0]
erd = row[2]
incid = row[3]
reqid = row[1]
t = run_sql_string_statement(
"SELECT CurrentStatus, ResourceName, DueDate FROM Resource WHERE ResourceID = {0};".format(
int(row[0])))
templist.append(resid)
templist.append(self.resdao.get_resname_by_resourceId(int(resid)))
templist.append(self.incidao.get_incident_description_by_incidentId(int(incid)))
templist.append(self.userdao.get_nameinfo_by_username(username))
templist.append(str(erd))
status = t[0][0]
if status != "available":
templist.append("reject")
else:
if self.repairResourcedao.get_count_by_resId(resid) == 0:
templist.append("cancelrepair")
else:
templist.append("deploy-reject")
templist.append(incid)
finalresult.append(templist)
return finalresult
def reject_button(self, resid, incid):
assert isinstance(resid, int)
assert isinstance(incid, int)
self.resreqdao.delete_by_resIdAndInciId(resid, incid)
def cancelrepair_button(self, resid):
assert isinstance(resid, int)
self.repairResourcedao.delete_by_resId(resid)
def deploy_button(self, resid, erd, username, inciid):
assert isinstance(resid, int)
assert isinstance(inciid, int)
today = str(datetime.datetime.today().date())
sql = "UPDATE Resource SET startDate ='{0}', DueDate = '{1}', CurrentStatus = 'not available', CurrentUser = '******' WHERE ResourceID = {3};"
run_sql_string_statement(sql.format(today, str(erd), username, resid))
self.resreqdao.delete_by_resIdAndInciId(resid, inciid)
def repairtable(self, username):
assert isinstance(username, str)
sql = "SELECT ResourceID, repairID, startDate, endDate FROM RepairResource WHERE ResourceID in (SELECT ResourceID FROM Resource WHERE Owner ='{0}')";
tempresult = run_sql_string_statement(sql.format(username))
finalre = list()
if len(tempresult) == 0 or len(tempresult[0]) == 0:
return finalre
for row in tempresult:
resid = int(row[0])
tm = list()
tm.append(resid)
tm.append(self.resdao.get_resname_by_resourceId(resid))
tm.append(str(row[2]))
tm.append(str(row[3]))
finalre.append(tm)
return finalre
def __init__(self):
logging.info("start the ActionButton_Dataservice")
self.resource_request_dao = ResourceRequest_DAO()
self.repair_resource_dao = RepairResource_DAO()
self.resource_dao = Resource_DAO()
def test_get_all_records(self):
rsd = Resource_DAO()
result = rsd.get_all_resource()
for row in result:
print row
"tomgovjuris" + str(i))
for i in range(0, 50):
User_DAO().insert("muni" + str(i), "muniinfo" + str(i), "pass" + str(i))
UserType_DAO.insert_record_to_municipalities("muni" + str(i), 1000 + i)
for i in range(0, 50):
User_DAO().insert("tomindi" + str(i), "tomindiinfo" + str(i),
"pass" + str(i))
UserType_DAO.insert_record_to_individual("tomindi" + str(i),
"tomindijobtitle" + str(i),
"2016-11-14")
for i in range(1, 50):
usernmae = "tomcompany" + str(i)
rsd = Resource_DAO()
count = rsd.get_count_as_int() + 1
if count / 3 == 0:
status = "available"
unit = "hour"
addi = [1, 2, 3, 4, 5, 6, 7]
cap = ["capa", "capb"]
if count / 5 == 0:
status = "in repair"
unit = "time"
addi = [14, 13, 5, 6, 7]
cap = ["capa", "capb", "capc"]
else:
status = "not available"
unit = "km"
class Search_Result_DataService():
#########################################################################
# if no incident selected, ignore distance calculation and return all resources
#########################################################################
def __init__(self):
logging.debug("start the Search_Result_DataService()")
self.res_dao = Resource_DAO()
self.inci_dao = Incident_DAO()
self.user_dao = User_DAO()
self.res_request_dao = ResourceRequest_DAO()
self.repair_resource_dao = RepairResource_DAO()
self.incidentEntry = ""
self.username = ""
def get_incident_position(self, incident_entry):
'''
@rtype: list
'''
assert isinstance(incident_entry, str)
temp = incident_entry[incident_entry.index("(") +
1:incident_entry.index(")")]
logging.debug("incident id is " + str(temp))
return self.inci_dao.get_incident_position_by_incidentId(int(temp))
def get_esf_id(self, esf_entry):
'''
@rtype: int
'''
assert isinstance(esf_entry, str)
temp = esf_entry[:esf_entry.index("#")]
logging.debug("esf id is " + str(temp))
return int(temp)
def get_resourceId_searched_by_esf(self, esfEntry):
'''
@rtype: list
'''
### includes the resoruce table, cap table, and esf table
assert isinstance(esfEntry, str)
srd = Search_Result_DataService()
esf_id = srd.get_esf_id(esfEntry)
from_primary = list()
from_additional = list()
from_primary = self.res_dao.get_resource_lists_by_primary_esf(esf_id)
from_additional = self.res_dao.get_resource_lists_by_additional_esf(
esf_id)
logging.debug(from_primary)
logging.debug(from_additional)
temp_set = set(from_primary + from_additional)
return list(temp_set)
def get_resourceId_searched_by_keyword(self, keyword):
'''
@rtype: list
'''
### includes the resoruce table, cap table, and esf table
assert isinstance(keyword, str)
from_res = list()
from_cap = list()
from_esf = list()
from_res = self.res_dao.get_resourceId_lists_by_keyword_model_or_name(
keyword)
from_cap = self.res_dao.get_resource_lists_by_keyword_capabilities(
keyword)
from_esf = self.res_dao.get_resource_lists_by_keyword_esf(keyword)
logging.debug(from_res)
logging.debug(from_cap)
logging.debug(from_esf)
temp_set = set(from_esf + from_res + from_cap)
return list(temp_set)
def get_distance_between_res_inci(self, inci_lat, inci_long, resoruceId):
'''
@rtype: float
'''
assert isinstance(inci_lat, float)
assert isinstance(inci_long, float)
assert isinstance(resoruceId, int)
res_pos = self.res_dao.get_resource_position_by_resourceId(resoruceId)
if len(res_pos) == 0:
return 0.0
res_lat = res_pos[0]
res_long = res_pos[1]
delta_lat = radians(res_lat) - radians(inci_lat)
delta_long = radians(res_long) - radians(inci_long)
a = sin(delta_lat / 2)**2 + cos(radians(inci_lat)) * cos(
radians(res_lat)) * sin(delta_long / 2)**2
c = 2 * atan2(sqrt(a), sqrt(1 - a))
return 6371 * c
def get_resIdDict_within_distance(self, incident_entry, distance,
res_id_lists):
'''
@rtype: dict
'''
assert isinstance(res_id_lists, list)
assert isinstance(incident_entry, str)
srd = Search_Result_DataService()
inci_lat = srd.get_incident_position(incident_entry)[0]
inci_long = srd.get_incident_position(incident_entry)[1]
result = dict()
for id in res_id_lists:
dist = srd.get_distance_between_res_inci(inci_lat, inci_long, id)
if dist <= distance:
result[id] = dist
sorted_result = sorted(result.items(), key=operator.itemgetter(0))
return dict(sorted_result)
def populate_table_data(self, keyword, esfEntry, location_distance,
incidenEntry):
'''
@rtype: dict
'''
assert isinstance(keyword, str)
assert isinstance(incidenEntry, str)
assert isinstance(esfEntry, str)
assert isinstance(location_distance, int)
srd = Search_Result_DataService()
table_lists = list()
if keyword != "" and esfEntry != "" and incidenEntry != "":
self.incidentEntry = incidenEntry
temp1 = srd.get_resourceId_searched_by_keyword(keyword)
temp2 = srd.get_resourceId_searched_by_esf(esfEntry)
tempset = set(temp1 + temp2)
resource_id_list = list(tempset)
resource_id_distance_dict = srd.get_resIdDict_within_distance(
incidenEntry, location_distance, resource_id_list)
logging.debug("final resourceid-distance mapping")
logging.debug(resource_id_distance_dict)
for k, v in resource_id_distance_dict.iteritems():
temp_list = list()
temp_list.append(k)
temp_list.append(v)
logging.debug(self.res_dao.get_resource_owner_by_resourceId(k))
temp_list.append(
self.user_dao.get_nameinfo_by_username(
self.res_dao.get_resource_owner_by_resourceId(k)))
temp_list.append(
self.res_dao.get_resource_costtext_by_resourceId(k))
temp_status = self.res_dao.get_resource_status_by_resourceId(k)
temp_list.append(temp_status)
if temp_status == "available":
temp_list.append("now")
if temp_status == "not available":
temp_list.append(
self.res_request_dao.
get_expectedreturndate_by_resourceId(k))
if temp_status == "in repair":
temp_list.append(
self.repair_resource_dao.get_enddate_by_resourceId(k))
table_lists.append(temp_list)
if keyword == "" and esfEntry != "" and incidenEntry != "":
self.incidentEntry = incidenEntry
temp2 = srd.get_resourceId_searched_by_esf(esfEntry)
tempset = set(temp2)
resource_id_list = list(tempset)
resource_id_distance_dict = srd.get_resIdDict_within_distance(
incidenEntry, location_distance, resource_id_list)
logging.debug("final resourceid-distance mapping")
logging.debug(resource_id_distance_dict)
for k, v in resource_id_distance_dict.iteritems():
temp_list = list()
temp_list.append(k)
temp_list.append(v)
logging.debug(self.res_dao.get_resource_owner_by_resourceId(k))
temp_list.append(
self.user_dao.get_nameinfo_by_username(
self.res_dao.get_resource_owner_by_resourceId(k)))
temp_list.append(
self.res_dao.get_resource_costtext_by_resourceId(k))
temp_status = self.res_dao.get_resource_status_by_resourceId(k)
temp_list.append(temp_status)
if temp_status == "available":
temp_list.append("now")
if temp_status == "not available":
temp_list.append(
self.res_request_dao.
get_expectedreturndate_by_resourceId(k))
if temp_status == "in repair":
temp_list.append(
self.repair_resource_dao.get_enddate_by_resourceId(k))
table_lists.append(temp_list)
if keyword == "" and esfEntry == "" and incidenEntry != "":
self.incidentEntry = incidenEntry
resource_id_list = list(self.res_dao.get_all_resource_id())
resource_id_distance_dict = srd.get_resIdDict_within_distance(
incidenEntry, location_distance, resource_id_list)
logging.debug("final resourceid-distance mapping")
logging.debug(resource_id_distance_dict)
for k, v in resource_id_distance_dict.iteritems():
temp_list = list()
temp_list.append(k)
temp_list.append(v)
logging.debug(self.res_dao.get_resource_owner_by_resourceId(k))
temp_list.append(
self.user_dao.get_nameinfo_by_username(
self.res_dao.get_resource_owner_by_resourceId(k)))
temp_list.append(
self.res_dao.get_resource_costtext_by_resourceId(k))
temp_status = self.res_dao.get_resource_status_by_resourceId(k)
temp_list.append(temp_status)
if temp_status == "available":
temp_list.append("now")
if temp_status == "not available":
temp_list.append(
self.res_request_dao.
get_expectedreturndate_by_resourceId(k))
if temp_status == "in repair":
temp_list.append(
self.repair_resource_dao.get_enddate_by_resourceId(k))
table_lists.append(temp_list)
if keyword == "" and esfEntry == "" and incidenEntry == "":
resource_id_list = list(self.res_dao.get_all_resource_id())
logging.debug("final resourceid-distance mapping")
for k in resource_id_list:
temp_list = list()
temp_list.append(k)
temp_list.append("N.A.")
logging.debug(self.res_dao.get_resource_owner_by_resourceId(k))
temp_list.append(
self.user_dao.get_nameinfo_by_username(
self.res_dao.get_resource_owner_by_resourceId(k)))
temp_list.append(
self.res_dao.get_resource_costtext_by_resourceId(k))
temp_status = self.res_dao.get_resource_status_by_resourceId(k)
temp_list.append(temp_status)
if temp_status == "available":
temp_list.append("now")
if temp_status == "not available":
temp_list.append(
self.res_request_dao.
get_expectedreturndate_by_resourceId(k))
if temp_status == "in repair":
temp_list.append(
self.repair_resource_dao.get_enddate_by_resourceId(k))
table_lists.append(temp_list)
return table_lists
def populate_action_lists(self, table_data_lists, username):
'''
@rtype: list
'''
assert isinstance(table_data_lists, list)
assert isinstance(username, str)
result = list()
for row in table_data_lists:
currentStatus = row[4]
logging.debug(currentStatus)
owner = str(
self.res_dao.get_resource_owner_by_resourceId(int(row[0])))
if currentStatus == "in repair" and owner != username:
temp = list()
result.append(temp)
if currentStatus == "not available":
temp = list()
temp.append("request")
result.append(temp)
if currentStatus == "available" and owner != username:
temp = list()
temp.append("request")
result.append(temp)
if currentStatus == "available" and owner == username:
temp = list()
startdate_repair = self.repair_resource_dao.get_startdate_by_resourceId(
int(row[0]))
currentDate = str(datetime.datetime.today().date())
print currentDate
print startdate_repair
if startdate_repair == "":
sd = datetime.datetime.strptime(currentDate, "%Y-%m-%d")
cd = datetime.datetime.strptime(currentDate, "%Y-%m-%d")
else:
sd = datetime.datetime.strptime(startdate_repair,
"%Y-%m-%d")
cd = datetime.datetime.strptime(currentDate, "%Y-%m-%d")
print sd
print cd
if sd < cd:
temp.append("cancel repair")
else:
if self.incidentEntry != "":
temp.append("deploy")
temp.append("repair")
else:
temp.append("repair")
result.append(temp)
if self.incidentEntry == "" and owner != username:
temp = list()
result.append(temp)
return result
