def remove(id):
"""
Removes a collection with id
:param id: int, id of the collection to be removed
:return: string, the name of the Collection which has been deleted
"""
logger.info("Removing Collection with id: {}".format(id))
# 0. Look up in database
c = Collection.query.get(id)
if c is not None: # if it exists then:
logger.info("Found Collection")
# 1. Remove from launcher_profiles.json
logger.info("Removing Profile from Minecraft Profiles")
mc_interface.rem_profile(c.mc_id)
name = copy.copy(c.name)
dir_loc = copy.copy(c.get_collection_path())
logger.info("Removing from database")
Collection.query.filter(Collection.id == id).delete()
db_session.commit()
# 2. Remove from Filesystem
logger.info("Removing from filesystem at: {}".format(dir_loc))
shutil.rmtree(dir_loc)
logger.info("Finished removing Collection: {}".format(name))
return name
else:
logger.error("Collection with id: {} doesn't exist".format(id))
raise exceptions.CollectionNotExistError(id)
def rem_mod(collection_id, mod_id):
"""
Removes a mod from the collection
:param collection_id: int, the id of the collection
:param mod_id: int, id of the mod
:return: None
"""
try:
collection_id = int(collection_id)
except ValueError:
logger.critical("Collection id is not a valid integer")
raise
try:
mod_id = int(mod_id)
except ValueError:
logger.critical("Mod id is not a valid integer")
raise
logger.info("Removing mod with id: {} from collection with id: {}".format(
mod_id, collection_id))
coll = Collection.query.get(collection_id)
mod = Mod.query.get(mod_id)
if mod is not None and coll is not None:
logger.info("Mod and Collection exist, proceeding to removal...")
if mod in coll.mods: # check if the mod is in this collection
logger.info("Removing symbolic link...")
try:
os.unlink(
join_path(config["application_root"], "collections",
coll.mc_id.decode(), "mods",
get_file_name(mod.filename)))
except FileNotFoundError:
logger.warning("Symlink already missing, continuing...")
logger.info("Symlink removed")
logger.info("Removing link from database...")
for m in Mod.query.filter(
and_(Mod.collections.any(id=collection_id),
Mod.filename == mod.filename)):
logger.debug("Removing Mod: {!r}".format(m))
coll.rem_mod(m)
db_session.commit()
logger.info("Database commit successful")
else:
logger.error("Mod is not in this collection, no action required")
logger.info("Mod removal successful")
elif mod is None:
logger.error("Mod does not exist")
raise exceptions.ModNotExistError(mod_id)
else:
logger.error("Collection doesn't exist")
raise exceptions.CollectionNotExistError(collection_id)
def add_mod(collection_id, mod_id):
"""
Adds a mod to a collection
:param collection_id: int
:param mod_id: int
:return: None
"""
try:
collection_id = int(collection_id)
except ValueError:
logger.critical("Collection id is not a valid integer")
raise
try:
mod_id = int(mod_id)
except ValueError:
logger.critical("Mod id is not a valid integer")
raise
logger.info("Adding mod {} to collection {}".format(mod_id, collection_id))
coll = Collection.query.get(collection_id)
mod = Mod.query.get(mod_id)
if mod is not None and coll is not None:
logger.info("Beginning addition...")
# 1. Create symlink
logger.info("Creating Symbolic link...")
try:
create_symbolic_link(
join_path(config["application_root"], "mods", mod.filename),
join_path(config["application_root"], "collections",
coll.mc_id.decode(), "mods",
get_file_name(mod.filename)))
except FileExistsError:
logger.warning("File already exists, continuing...")
logger.info("Symlink created")
# 2. Add relationship to database, for all mods in this file
for m in Mod.query.filter(Mod.filename == mod.filename):
logger.debug(
"Adding mod: {!r} to collection: {!r} in database".format(
m, coll))
coll.add_mod(m)
db_session.commit()
logger.info("Mod added successfully")
elif mod is None:
logger.error("Mod does not exist")
raise exceptions.ModNotExistError(mod_id)
else:
logger.error("Collection does not exist")
raise exceptions.CollectionNotExistError(collection_id)
def _add_mod_author(self, m, author):
"""
Adds a mod author
:param m: Mod
:param author: String
:return: None
"""
self.logger.debug("Adding a new Author: {}".format(author))
x = ModAuthor(author)
db_session.add(x)
db_session.commit()
m.authors.append(x)
self.logger.debug("Successfully added Author")
def _add_mod_dependency(self, m, modid):
"""
Adds a mod dependency
:param m: Mod
:param modid: String
:return: None
"""
self.logger.debug("Looking up DepMod for modid: {}".format(modid))
x = DepMod.query.get(modid)
if x is None:
self.logger.debug("DepMod doesn't yet exist, creating one")
x = DepMod(modid)
db_session.add(x)
db_session.commit()
self.logger.debug("Added to database successfully")
m.dependencies.append(x)
self.logger.debug("Successfully added dependency")
def add_collection(args):
"""
Add a collection to the database
:param args:
:return: None
"""
lookup = Collection.query.filter(
Collection.name == args.get("name")).first()
print(lookup)
if lookup:
#return '/collection/{}'.format(lookup.id) # a collection by that name already exists
return "/collection/{}".format(lookup.id)
else:
coll = Collection(args.get("name"), args.get("mcversion"),
args.get("version_id"))
db_session.add(coll)
db_session.commit()
return '/collection/{}'.format(coll.id)
def add(name, mcversion, version_id):
"""
Adds a new collection (if it doesn't exist already) to the DB, Minecraft, & the FileSystem
:param name: string, user-friendly name of the Collection
:param mcversion: string, general Minecraft Version for the collection. e.g. 1.7.10
:param version_id: string, exact name of a specific version of minecraft. e.g. 1.7.10-Forge10.13.4.1558-1.7.10
:return: int, id of the newly created Collection
"""
logger.info("Adding collection: {}, {}, {}".format(name, mcversion,
version_id))
if not name_exists(
name): # if a Collection by this name doesn't yet exist:
# 1. Add it to the database
logger.info("Adding to database")
c = Collection(name, mcversion, version_id)
db_session.add(c)
db_session.commit()
logger.info("Committed to database")
# 2. Creates it's directory and filesystem
logger.info("Creating filesystem...")
coll_loc = _create_collection_filesystem(
join_path(config["application_root"], "collections"), c.mc_id)
logger.info("Filesystem created")
# 3. Add it to Minecraft as a Profile
logger.info("Adding Minecraft Profile")
prof = mc_interface.Profile(c.mc_id, name, version_id, coll_loc)
prof.commit()
logger.info("New Profile committed")
print(
mc_interface.Profile(c.mc_id, name, version_id,
coll_loc).dictify())
return c.id
else:
logger.error(
"A Collection with the name: {} already exists".format(name))
raise exceptions.CollectionExistsError(
str(Collection.query.filter(Collection.name == name).first().id))
def add_to_database(self,
filename,
dl_url=None,
curse_id=None,
curse_file_id=None):
"""
Add each mod to the database
:param filename: string, absolute path to the filename
:param dl_url: string, URL the mod was downloaded from, if it was acquired via direct DL
:return: None
"""
self.logger.debug("Adding mods to database...")
for mod in self.mods:
mod.add_to_database(filename,
dl_url,
curse_id=None,
curse_file_id=None)
# commit all of the changes
db_session.commit()
self.logger.debug("Mod Commit successful")
"""
Creates the moddata.sqlite database
"""
from simple_mod_installer.database import init_db, db_session
from simple_mod_installer.database.models import *
# create the database
init_db()
# create collection
c = Collection("test", "1.7.10", "Minecraft 1.7.10")
db_session.add(c)
db_session.commit()
def remove(id):
"""
Removes a mod from the filesystem and database, including deletion of all links to collections
:param id: int
:return: None
"""
logger.info("Beginning removal of mod with id: {}".format(id))
# 0. Get file name:
logger.debug("Getting Mod from database...")
m = Mod.query.get(id)
if m is None:
logger.error("Mod doesn't exist in database")
raise exceptions.ModNotExistError(id)
filename = m.filename
if filename is None:
logger.critical(
"Database entry is missing mission-critical filename data. Throwing error..."
)
raise exceptions.ModInfoNotExistError(id, 'filename')
# 1. Remove all symlinks in Collections
logger.info("Removing from collections: {}".format(m.collections))
for coll in m.collections:
logger.debug("Working with collection {}...".format(coll.id))
logger.debug("Removing Symbolic link...")
try:
os.unlink(
join_path(config["application_root"], "collections",
coll.mc_id.decode(), "mods", filename))
except FileNotFoundError as ex:
logger.error("Symlink doesn't exist")
except OSError as ex:
logger.critical(
"Insufficient Permissions for Symbolic link manipulation: {}".
format(ex.args))
logger.debug("Symlink removed successfully")
logger.debug("Removing relationship...")
coll.rem_mod(m)
logger.debug("Relationship removed")
logger.info("Finished removing from collections")
# 2. Delete mod file:
logger.info("Deleting mod file...")
os.remove(join_path(config["application_root"], "mods", filename))
logger.info("Deletion successful")
# 3. Delete Mod from database
logger.info("Removing from database...")
for mod in Mod.query.filter(Mod.filename == m.filename):
logger.debug("Removing mod: {!r} from database".format(mod))
db_session.delete(mod)
logger.info("Removed")
logger.debug("Committing Database changes...")
db_session.commit()
logger.debug("Commit successful")
logger.info("Finished Removing mod with id {}".format(id))