protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
SetPartsGridView.AutoGenerateColumns = false;
if (!SettingsManager.HasInitialized)
{
SettingsManager.Initialize();
}
LDDEnvironment.Initialize();
RebrickableAPI.ApiKey = "aU49o5xulf";
RebrickableAPI.InitializeClient();
DBFilePath = SettingsManager.GetFilePath(SettingsManager.DATABASE_FILENAME);
var currentFolder = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
//DBFilePath = Path.Combine(currentFolder, "BrickDatabase.db");
//if (!File.Exists(DBFilePath))
// File.Copy(currentFolder + "\\Resources\\EmptyDatabase.db", DBFilePath);
if (SettingsManager.DatabaseExists())
{
ReloadRebrickableBaseData();
}
else
{
InitDatabase();
}
}
public void ImportThemes()
{
using (var trans = Connection.BeginTransaction())
using (var cmd = Connection.CreateCommand())
{
cmd.CommandText = $"DELETE FROM {DbHelper.GetTableName<RbTheme>()}";
cmd.ExecuteNonQuery();
cmd.CommandText = $"DELETE FROM sqlite_sequence WHERE name='{DbHelper.GetTableName<RbTheme>()}'";
cmd.ExecuteNonQuery();
NotifyIndefiniteProgress("Downloading rebrickable themes...");
var themes = RebrickableAPI.GetAllThemes().ToList();
NotifyTaskStart("Importing themes...", themes.Count);
DbHelper.InitializeInsertCommand <RbTheme>(cmd, x => new { x.ID, x.Name, x.ParentThemeID });
int totalToProcess = themes.Count;
int totalProcessed = 0;
foreach (var rbTheme in themes)
{
if (IsCancellationRequested)
{
break;
}
DbHelper.InsertWithParameters(cmd, rbTheme.Id, rbTheme.Name, rbTheme.ParentID);
ReportProgress(++totalProcessed, totalToProcess);
}
trans.Commit();
}
}
private void button1_Click(object sender, EventArgs e)
{
Task.Factory.StartNew(() =>
{
var SetInfo = RebrickableAPI.GetSet("10019-1"); //10019-1
var setParts = RebrickableAPI.GetSetParts(SetInfo.SetNum).ToList();
BeginInvoke((Action)(() => LoadSetParts(setParts)));
//PalatteGenerator.CreatePaletteFromSet(DBFilePath, setInfo);
});
}
private void button2_Click(object sender, EventArgs e)
{
Task.Factory.StartNew(() =>
{
try
{
SetInfo = RebrickableAPI.GetSet(textBox1.Text);
if (SetInfo != null)
{
var setParts = RebrickableAPI.GetSetParts(SetInfo.SetNum).ToList();
BeginInvoke((Action)(() => LoadSetParts(setParts)));
//PalatteGenerator.CreatePaletteFromSet(DBFilePath, setInfo);
}
}
catch { }
});
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (!SettingsManager.HasInitialized)
{
SettingsManager.Initialize();
}
LDDEnvironment.Initialize();
RebrickableAPI.ApiKey = "aU49o5xulf";
RebrickableAPI.InitializeClient();
if (!SettingsManager.DatabaseExists())
{
using (var win = new DatabaseInitProgressWindow())
{
win.StartPosition = FormStartPosition.CenterParent;
win.ShowDialog();
}
}
}
public void ImportSets()
{
NotifyBeginStep("Importing sets");
using (var trans = Connection.BeginTransaction())
using (var cmd = Connection.CreateCommand())
{
cmd.CommandText = $"DELETE FROM {DbHelper.GetTableName<RbSet>()}";
cmd.ExecuteNonQuery();
cmd.CommandText = $"DELETE FROM sqlite_sequence WHERE name='{DbHelper.GetTableName<RbSet>()}'";
cmd.ExecuteNonQuery();
NotifyIndefiniteProgress("Downloading rebrickable sets...");
var sets = RebrickableAPI.GetSets(minYear: 2018).ToList();
NotifyTaskStart("Importing sets...", sets.Count);
DbHelper.InitializeInsertCommand <RbSet>(cmd, x => new { x.SetID, x.Name, x.ThemeID, x.Year, x.InventoryDate });
int totalToProcess = sets.Count;
int totalProcessed = 0;
foreach (var rbSet in sets)
{
if (IsCancellationRequested)
{
break;
}
DbHelper.InsertWithParameters(cmd, rbSet.SetNum, rbSet.Name, rbSet.ThemeId, rbSet.Year, DateTime.Now);
ReportProgress(++totalProcessed, totalToProcess);
}
trans.Commit();
}
}
public void ImportColors()
{
using (var trans = Connection.BeginTransaction())
using (var colorCmd = Connection.CreateCommand())
using (var matchCmd = Connection.CreateCommand())
{
colorCmd.CommandText = $"DELETE FROM {DbHelper.GetTableName<RbColorMatch>()}";
colorCmd.ExecuteNonQuery();
colorCmd.CommandText = $"DELETE FROM {DbHelper.GetTableName<RbColor>()}";
colorCmd.ExecuteNonQuery();
colorCmd.CommandText = $"DELETE FROM sqlite_sequence WHERE name='{DbHelper.GetTableName<RbColorMatch>()}'";
colorCmd.ExecuteNonQuery();
colorCmd.CommandText = $"DELETE FROM sqlite_sequence WHERE name='{DbHelper.GetTableName<RbColor>()}'";
colorCmd.ExecuteNonQuery();
NotifyIndefiniteProgress("Downloading rebrickable colors...");
var colors = RebrickableAPI.GetAllColors().ToList();
NotifyTaskStart("Importing colors...", colors.Count);
DbHelper.InitializeInsertCommand <RbColor>(colorCmd, x =>
new
{
x.ID,
x.Name,
x.IsTransparent,
x.RgbHex
});
DbHelper.InitializeInsertCommand <RbColorMatch>(matchCmd, x =>
new
{
x.RbColorID,
x.Platform,
x.ColorID,
x.ColorName
});
int totalToProcess = colors.Count;
int totalProcessed = 0;
void AddColorMatches(int colorID, PaletteMaker.Rebrickable.Models.ColorIds colorIds, string platform)
{
int colorCount = colorIds?.ExtIds?.Count ?? 0;
for (int i = 0; i < colorCount; i++)
{
DbHelper.InsertWithParameters(matchCmd,
colorID,
platform,
colorIds.ExtIds[i],
colorIds.ExtDescrs[i][0]
);
}
}
foreach (var rbColor in colors)
{
if (IsCancellationRequested)
{
break;
}
DbHelper.InsertWithParameters(colorCmd,
rbColor.Id,
rbColor.Name,
rbColor.IsTransparent,
rbColor.RgbHex
);
AddColorMatches(rbColor.Id, rbColor.ExternalColorIds.LEGO, "LEGO");
AddColorMatches(rbColor.Id, rbColor.ExternalColorIds.BrickLink, "BrickLink");
ReportProgress(++totalProcessed, totalToProcess);
}
trans.Commit();
}
}
public static void FindLddPartsForSet(PaletteDbContext db, List <SetPartWrapper> setParts)
{
var rbColors = new Dictionary <int, RbColor>();
foreach (var col in db.Colors)
{
rbColors.Add(col.ID, col);
}
foreach (var setPart in setParts)
{
if (setPart.CategoryID == 17 || setPart.CategoryID == 58)
{
setPart.MatchingFlags = PartMatchingFlags.NonLegoPart;
continue;
}
setPart.RbPart = db.RbParts.FirstOrDefault(x => x.PartID == setPart.PartID);
if (setPart.RbPart == null)
{
setPart.MatchingFlags = PartMatchingFlags.InvalidRbPart;
continue;
}
if (!rbColors.TryGetValue(setPart.ColorID, out RbColor rbColor))
{
setPart.MatchingFlags |= PartMatchingFlags.InvalidRbColor;
//continue;
}
var lddColor = rbColor.ColorMatches.Where(x => x.Platform == "LEGO").OrderBy(x => x.ColorID).FirstOrDefault();
if (lddColor == null)
{
setPart.MatchingFlags |= PartMatchingFlags.InvalidLddColor;
//continue;
}
setPart.LddColorID = lddColor?.ColorID ?? -1;
if (!string.IsNullOrEmpty(setPart.ElementID))
{
var foundElem = db.LddElements.FirstOrDefault(x => x.ElementID == setPart.ElementID);
if (foundElem != null)
{
setPart.LddElement = foundElem;
setPart.IsGeneratedElement = false;
setPart.LddPart = db.LddParts.FirstOrDefault(x => x.DesignID == foundElem.DesignID);
if (setPart.LddPart != null)
{
setPart.MatchingFlags = PartMatchingFlags.Matched;
continue;
}
}
}
var lddPart = FindLddPart(db, setPart.RbPart);
if (lddPart == null)
{
setPart.MatchingFlags = PartMatchingFlags.LddPartNotFound;
continue;
}
//Fix LDD elements that references part aliases
if (setPart.LddElement != null)
{
Debug.WriteLine("Encountered LDD Element on part alias");
string aliasID = setPart.LddElement.DesignID;
setPart.LddElement.DesignID = lddPart.DesignID;
foreach (var p in setPart.LddElement.Parts)
{
if (p.PartID == aliasID)
{
p.PartID = lddPart.DesignID;
}
}
db.SaveChanges();
}
setPart.LddPart = lddPart;
setPart.MatchingFlags = PartMatchingFlags.Matched;
}
foreach (var part in setParts.Where(x => x.MatchingFlags == PartMatchingFlags.Matched))
{
Debug.WriteLine($"Matched Part '{part.PartName}' ({part.PartID}) to LDD ID {part.LddPartID}");
}
var unmatchedParts = setParts.Where(x => x.MatchingFlags == PartMatchingFlags.LddPartNotFound).ToList();
if (unmatchedParts.Any())
{
Debug.WriteLine("Querying rebrickable....");
var newMappings = new List <Models.PartMapping>();
var partDetails = RebrickableAPI.GetPartsDetails(unmatchedParts.Select(x => x.PartID).Distinct()).ToList();
foreach (var partDetail in partDetails)
{
if (partDetail.ExternalIds.LEGO?.Count > 0)
{
var relatedSetParts = unmatchedParts.Where(x => x.PartID == partDetail.PartNum).ToList();
var legoPartIDs = partDetail.ExternalIds.LEGO.ToArray();
relatedSetParts.ForEach(x => x.LegoIDs.AddRange(legoPartIDs));
var matchingParts = db.LddParts.Where(x => legoPartIDs.Contains(x.DesignID)).ToList();
var foundPart = matchingParts.FirstOrDefault();
if (foundPart != null)
{
Debug.WriteLine($"Matched Part '{partDetail.Name}' ({partDetail.PartNum}) to LDD ID {foundPart.DesignID}");
var rbPart = db.RbParts.FirstOrDefault(x => x.PartID == partDetail.PartNum);
if (!newMappings.Any(x => x.RebrickableID == (rbPart.ParentPartID ?? rbPart.PartID)))
{
newMappings.Add(new Models.PartMapping()
{
RebrickableID = rbPart.ParentPartID ?? rbPart.PartID,
LegoID = foundPart.DesignID,
MatchLevel = 3,
IsActive = true
});
}
foreach (var setPart in unmatchedParts.Where(x => x.PartID == partDetail.PartNum))
{
setPart.LddPart = foundPart;
setPart.MatchingFlags |= PartMatchingFlags.Matched;
}
}
}
}
if (newMappings.Any())
{
db.PartMappings.AddRange(newMappings);
db.SaveChanges();
}
}
foreach (var part in setParts.Where(x => x.LddPartFound && x.LddElement == null))
{
part.LddElement = GenererateElement(db, part);
part.IsGeneratedElement = (part.LddElement != null);
}
foreach (var part in setParts.Where(x => x.MatchingFlags == PartMatchingFlags.LddPartNotFound))
{
Debug.WriteLine($"Part '{part.PartName}' ({part.PartID}) not found in LDD");
}
}