private UpsertResult <Pricing> UpsertPricing(Printing printing, JObject prices, bool foil)
{
var result = new UpsertResult <Pricing>();
var properties = prices.Properties();
foreach (var property in properties)
{
if (DateTime.TryParse(property.Name, out DateTime date))
{
var dbPricing = printing.Pricings.Where(p => p.Date.Date == date.Date && p.Foil == foil).FirstOrDefault();
if (dbPricing == null)
{
dbPricing = new Pricing()
{
Printing = printing,
Foil = foil,
Date = date
};
//db.Pricings.Add(dbPricing);
result.ObjectsToAdd.Add(dbPricing);
}
dbPricing.Price = property.Value.HasValues ? (double)property.Value : 0;
}
}
return(result);
}
/// <summary>
/// Upsert a player into the PLAYERS table.
/// </summary>
/// <param name="player">A WoWDotNetAPI.Modules.Character object.</param>
/// <returns>The result of a player upsert.</returns>
public UpsertResult UpdatePlayer(Character player)
{
if (!_isdbopen)
{
this.Open();
}
SQLiteCommand cmd = null;
StringBuilder sb = new StringBuilder();
int numrows = 0;
string sql = "";
bool ret = false;
UpsertResult result = new UpsertResult();
// check if player exists
ret = DoesPlayersExist(player.Name);
if (ret)
{
// player exists so build update query
sql = BuildUpdatePlayerSQL(player);
result = UpsertResult.UPDATED;
}
else
{
// player does not exists so build insert query
sql = BuildInsertPlayerSQL(player);
result = UpsertResult.INSERTED;
}
cmd = new SQLiteCommand(sql, _cnn);
try
{
numrows += cmd.ExecuteNonQuery();
// //if (GuildInfoUpdated != null)
// //{
// // // someone is subscribed, throw event
// // GuildInfoUpdated(this, new EventArgs());
// //}
}
catch (SQLiteException se)
{
Console.WriteLine(se.Message);
result = UpsertResult.ERROR;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
result = UpsertResult.ERROR;
}
return(result);
}
public virtual UpsertResult <TDomain> Upsert(TDomain domain)
{
var saved = Set
.FindOptional(domain.Id)
.CreateIfNone()
.MapFrom(domain)
.MatchNew <TEntity, TKey>(entity => Set.Add(entity))
.Do(Context.SaveChanges)
.Map(entity => GetById(entity.Id))
.ValueOrFailure();
return(UpsertResult <TDomain> .Ok(saved));
}
public override UpsertResult <IbanDomain> Upsert(IbanDomain domain)
{
domain.IbanStr = domain.IbanStr?.Replace(" ", "");
var saved = Set
.FindOptional(domain.Id)
.CreateIfNone()
.MapFrom(domain)
.MatchNew <Iban, long>(entity => Set.Add(entity))
.Do(Context.SaveChanges)
.Map(entity => GetById(entity.Id))
.ValueOrFailure();
return(UpsertResult <IbanDomain> .Ok(saved));
}
public async Task <UpsertResult <Personnel> > UpsertAsync(Personnel personnel, CancellationToken cancel,
int?parentId = null)
{
var result = new UpsertResult <Personnel>();
if (personnel.PersonnelId.HasValue && personnel.PersonnelId.Value > 0)
{
result.Action = UpsertAction.Updated;
result.Data = await UpdateAsync(personnel, cancel);
}
else
{
result.Action = UpsertAction.Created;
result.Data = await CreateAsync(personnel, cancel);
}
return(result);
}
public async Task <UpsertResult <Studio> > UpsertAsync(Studio entity, CancellationToken cancelToken,
int?parentId = null)
{
var result = new UpsertResult <Studio>();
if (entity.StudioID.HasValue && entity.StudioID.Value > 0)
{
result.Action = UpsertAction.Updated;
result.Data = await UpdateAsync(entity, cancelToken);
}
else
{
result.Action = UpsertAction.Created;
result.Data = await CreateAsync(entity, cancelToken);
}
return(result);
}
public async Task <UpsertResult <ContactAddress> > UpsertAsync(ContactAddress entity,
CancellationToken cancelToken, int?parentId = null)
{
var result = new UpsertResult <ContactAddress>();
if (entity.AddressID > 0)
{
result.Action = UpsertAction.Updated;
result.Data = await UpdateAsync(entity, cancelToken);
}
else
{
result.Action = UpsertAction.Created;
result.Data = await CreateAsync(entity, cancelToken, parentId);
}
return(result);
}
public async Task <UpsertResult <StaffTeam> > UpsertAsync(StaffTeam entity, CancellationToken cancelToken,
int?parentId = null)
{
var result = new UpsertResult <StaffTeam>();
if (entity.OppStaffTeamID > 0)
{
result.Action = UpsertAction.Updated;
result.Data = await UpdateAsync(entity, cancelToken);
}
else
{
result.Action = UpsertAction.Created;
result.Data = await CreateAsync(entity, cancelToken);
}
return(result);
}
public void UpsertResultClass_Properties_TestGetterAndSetter()
{
// Arrange
var testEntity = new UpsertResult();
var privateObject = new PrivateObject(testEntity);
var propertiesDictionary = new Dictionary <string, object>()
{
["created"] = true,
["errors"] = new Error[] { },
["id"] = DummyString,
["success"] = true,
};
// Act
SetProperties(privateObject, propertiesDictionary);
// Assert
AssertProperties(privateObject, propertiesDictionary);
}
private UpsertResult <Set> UpsertSet(JsonSet set)
{
var result = new UpsertResult <Set>();
var dbSet = db.Sets.Local
.Where(s => s.Name == set.Name)
.FirstOrDefault();
if (dbSet == null)
{
dbSet = new Set()
{
Name = set.Name
};
result.ObjectsToAdd.Add(dbSet);
}
dbSet.Code = set.Code;
dbSet.KeyruneCode = set.KeyruneCode;
dbSet.Date = set.ReleaseDate;
dbSet.SetType = UpsertSimpleLookup(db.SetTypes, set.Type);
dbSet.Block = UpsertSimpleLookup(db.Blocks, set.Block);
foreach (var card in set.Cards)
{
var printingUpsert = this.UpsertPrinting(card);
result.Merge(printingUpsert);
if (printingUpsert.MainObject != null)
{
dbSet.Printings.Add(printingUpsert.MainObject);
}
}
result.MainObject = dbSet;
return(result);
}
private UpsertResult <Legality> UpsertLegality(Card card, string format, bool legal, bool leader)
{
var result = new UpsertResult <Legality>();
var legality = card.Legalities.SingleOrDefault(l => l.Format == format);
if (legality == null)
{
legality = new Legality()
{
Card = card,
Format = format
};
result.ObjectsToAdd.Add(legality);
}
legality.Legal = legal;
legality.LegalAsCommander = leader;
result.MainObject = legality;
return(result);
}
/// <summary>
/// Pass a populated Member in and it will update salesforce.
/// </summary>
/// <param name="newMember"></param>
/// <returns>SalesforceSaveResult with success/fail bool & message if there was an error</returns>
public SalesforceActionResult CreateWebsiteMemberAsContact(Member newMember, string newMemberEmail) //member needs to be updated to have an email field
{
////sf upserts have to happen in the proper order. upsert the member first
// each join / lookup value can be upsert after the member exists
// then we upsert child
// then we can upsert child lookup values
SalesforceActionResult sfResult = new SalesforceActionResult();
Contact newSalesforceContact = new Contact();
//Created an account for Understood.org
newSalesforceContact.AccountId = "001F0000014EhHtIAK"; //todo Move this and other similar values into a config
//check required values
if (string.IsNullOrEmpty(newMember.FirstName))
{
throw new Exception("First Name is required to save a new Contact Member to Service.");
}
else
{
newSalesforceContact.FirstName = newMember.FirstName;
newSalesforceContact.member_FirstName__c = newMember.FirstName;
}
if (string.IsNullOrEmpty(newMember.LastName))
{
//last name will always be empty for now.
//throw new Exception("Last Name is required to save a new Website Contact Member to Service.");
newMember.LastName = "NotSpecified";
newSalesforceContact.LastName = newMember.LastName;
newSalesforceContact.member_LastName__c = newMember.LastName;
}
else
{
newSalesforceContact.LastName = newMember.LastName;
newSalesforceContact.member_LastName__c = newMember.LastName;
}
newSalesforceContact.member_MemberId__c = newMember.MemberId.ToString(); //member_MemberId__c is our sfdc external uid on Contact
newSalesforceContact.member_UserId__c = newMember.UserId.ToString();
if (newMember.ScreenName == "Screen Name")//more garbage coming through
{
Random random = new Random();
int randomNumber = random.Next(0, 30000);
newMember.ScreenName = "ScreenName_" + randomNumber.ToString();
}
newSalesforceContact.member_ScreenName__c = newMember.ScreenName;
//Discovered that if you do not set both the field, and the specififed field, you don't update the checkbocx
newSalesforceContact.member_allowConnections__c = newMember.allowConnections;
newSalesforceContact.member_allowConnections__cSpecified = newMember.allowConnections;
newSalesforceContact.member_allowNewsletter__c = newMember.allowNewsletter;
newSalesforceContact.member_allowNewsletter__cSpecified = newMember.allowNewsletter;
newSalesforceContact.member_emailSubscription__c = newMember.emailSubscription;
newSalesforceContact.member_emailSubscription__cSpecified = newMember.emailSubscription;
newSalesforceContact.member_hasOtherChildren__c = newMember.hasOtherChildren;
newSalesforceContact.member_hasOtherChildren__cSpecified = newMember.hasOtherChildren;
newSalesforceContact.member_isFacebookUser__c = newMember.isFacebookUser;
newSalesforceContact.member_isFacebookUser__cSpecified = newMember.isFacebookUser;
newSalesforceContact.member_isPrivate__c = newMember.isPrivate;
newSalesforceContact.member_isPrivate__cSpecified = newMember.isPrivate;
newSalesforceContact.member_ZipCode__c = newMember.ZipCode;
newSalesforceContact.Email = newMemberEmail;
//garbage is getting in still.
if (newMember.Role != new Guid("{00000000-0000-0000-0000-000000000000}"))
{
newSalesforceContact.member_Role__c = Constants.SalesforceLookupDictionary[newMember.Role];
}
//Journey may be null
if (newMember.Journeys.Count >= 1)
{
newSalesforceContact.Journey__c = Constants.SalesforceLookupDictionary[newMember.Journeys.First().Key];
}
//ContactsPersonality
//THERE IS ALSO A PERSONALITYTYPE IN THE WSDL. DO NOT USE IT.
if (!string.IsNullOrEmpty(newMember.PersonalityType.ToString()))
{
//garbage is getting in. skip garbage.
if (newMember.PersonalityType != new Guid("{00000000-0000-0000-0000-000000000000}"))
{
newSalesforceContact.member_Personality__c = Constants.SalesforceLookupDictionary[newMember.PersonalityType];//.ToString();
}
}
//exernal id field name is not the value of the userid. its our guid for member. the name of the field/column in sfdc
//sfdc needs to know the primary, unique key to look for when updating existing rows
UpsertResult result = _sfs.upsert("member_MemberId__c",
new sObject[] { newSalesforceContact })[0];
string SalesforceNewContactId = string.Empty;
if (result.success == false) //failed to create member. stop upserts. return.
{
sfResult.Success = false;
sfResult.Message = "An error occured during the upsert to Salesforce." +
Environment.NewLine;
foreach (Error e in result.errors)
{
sfResult.Message += "* " + e.message + Environment.NewLine;
}
return(sfResult);
}
else
{
SalesforceNewContactId = result.id; // lets see if this was smart enough to update our contact
}
//create entrires for Interests
foreach (Interest i in newMember.Interests)
{
MemberToInterests__c sfdcMembertoInterest = new MemberToInterests__c();
//i believe that I am going to need to get the ID of the user that was just created.
// membertoInterest.MemberMaster__c = newMember.UserId.ToString();
sfdcMembertoInterest.MemberMaster__c = SalesforceNewContactId;
//lookup the Salesforce Id from the Sitecore Guid
sfdcMembertoInterest.MemberInterest__c = Constants.SalesforceLookupDictionary[i.Key];
sfdcMembertoInterest.Name = i.Value;
//NEED to use an exernal id for any upserted rows....
//i think for masterdetail records we want to just do an INSERT
SaveResult interestSaveResult = _sfs.create(new sObject[] { sfdcMembertoInterest })[0];
if (interestSaveResult.success == false)
{
sfResult.Success = false;
sfResult.Message = "An error occured during the upsert to Salesforce. Upserting Interest entries did not succeed." +
Environment.NewLine + "Error Messages: " + Environment.NewLine;
foreach (Error e in interestSaveResult.errors)
{
sfResult.Message += "Status code: (" + e.statusCode + ") Message: " + e.message + Environment.NewLine;
}
return(sfResult);
}
}
//add children to salesforce
foreach (Child c in newMember.Children)
{
Children__c sfdcChild = new Children__c();
sfdcChild.ContactChild__c = SalesforceNewContactId;
sfdcChild.Grade__c = Constants.SalesforceLookupDictionary[(c.Grades.First().Key)];
//these are blowing up with garbage values getting through
if (c.Section504Status != new Guid("{00000000-0000-0000-0000-000000000000}"))
{
sfdcChild.ChildTo504Status__c = Constants.SalesforceLookupDictionary[c.Section504Status];
}
if (c.EvaluationStatus != new Guid("{00000000-0000-0000-0000-000000000000}"))
{
sfdcChild.ChildToEvaluationStatus__c = Constants.SalesforceLookupDictionary[c.EvaluationStatus];
}
if (c.IEPStatus != new Guid("{00000000-0000-0000-0000-000000000000}"))
{
sfdcChild.ChildToIEPStatus__c = Constants.SalesforceLookupDictionary[c.IEPStatus];
}
sfdcChild.Nickname__c = c.Nickname;
sfdcChild.Name = c.Nickname;
//include a guid for the child's id
sfdcChild.UnderstoodChildId__c = c.ChildId.ToString();
SaveResult sfdcChildSaveResult = _sfs.create(new sObject[] { sfdcChild })[0];
if (sfdcChildSaveResult.success == false)
{
sfResult.Success = false;
sfResult.Message = "An error occured during the upsert to Salesforce. Upserting the Members Children did not succeed." +
Environment.NewLine + "Error Messages: " + Environment.NewLine;
foreach (Error e in sfdcChildSaveResult.errors)
{
sfResult.Message += "Status code: (" + e.statusCode + ") Message: " + e.message + Environment.NewLine;
}
return(sfResult);
}
//=====================================================================================================
//with this child successfully created, we can now add rows to other objects that reference the child
//get the new child's salesforce id and add in issues into the salesforce lookup object
foreach (Issue childIssue in c.Issues)
{
ChildToIssues__c sfdcforceChildIssues = new ChildToIssues__c();
sfdcforceChildIssues.ChildMaster__c = sfdcChildSaveResult.id; //we get back the ID that salesforce made during create
sfdcforceChildIssues.ChildIssue__c = Constants.SalesforceLookupDictionary[childIssue.Key];
sfdcforceChildIssues.Name = childIssue.Value;
SaveResult sr = _sfs.create(new sObject[] { sfdcforceChildIssues })[0];
if (sr.success == false)
{
sfResult.Success = false;
sfResult.Message = "An error occured during the upsert to Salesforce. Creating the Issues of Children did not succeed." +
Environment.NewLine + "Error Messages: " + Environment.NewLine;
foreach (Error e in sr.errors)
{
sfResult.Message += "Status code: (" + e.statusCode + ") Message: " + e.message + Environment.NewLine;
}
return(sfResult);
}//-------------------
sfResult.Message = Environment.NewLine +
"Save Result for Issue (Name:" + sfdcforceChildIssues.Name + Environment.NewLine +
"|Issue:" + sfdcforceChildIssues.ChildIssue__c + Environment.NewLine +
" |Success:" + sr.success.ToString();
}
//save child diagnosis values
foreach (Diagnosis childDiagnosis in c.Diagnoses)
{
ChildToDiagnosis__c salesforceChildDiagnosis = new ChildToDiagnosis__c();
salesforceChildDiagnosis.ChildMaster__c = sfdcChildSaveResult.id;
salesforceChildDiagnosis.ChildDiagnosis__c = Constants.SalesforceLookupDictionary[childDiagnosis.Key];
salesforceChildDiagnosis.Name = childDiagnosis.Value;
SaveResult sr = _sfs.create(new sObject[] { salesforceChildDiagnosis })[0];
if (sr.success == false)
{
sfResult.Success = false;
sfResult.Message = "Error when saving child Diagnosis: " + sr.errors.First().message;
return(sfResult);
}
}
}
//
return(sfResult);
}
public void WhenUpserterRunsForTwoSimpleIntsArrays()
{
_result = _upserter.Run(new[] { 1, 2, 3, 4, 5 }, new[] { 5, 2, 9, 10 });
}
private UpsertResult <Printing> UpsertPrinting(JsonCard printing)
{
var card = this.UpsertCard(printing);
if (card.ObjectsToRemove.Count > 0)
{
db.RemoveRange(card.ObjectsToRemove);
}
if (card.ObjectsToAdd.Count > 0)
{
db.AddRange(card.ObjectsToAdd);
}
var result = new UpsertResult <Printing>();
if (!printing.Identifiers.MultiverseId.HasValue)
{
return(result);
}
var dbPrinting = db.Printings.Local
.Where(p => p.MultiverseId == printing.Identifiers.MultiverseId.Value && p.Side == printing.Side)
.FirstOrDefault();
if (dbPrinting == null)
{
dbPrinting = new Printing()
{
MultiverseId = printing.Identifiers.MultiverseId.Value,
Side = printing.Side
};
result.ObjectsToAdd.Add(dbPrinting);
}
dbPrinting.UUID = printing.UUID;
dbPrinting.FlavorText = printing.FlavorText;
dbPrinting.CollectorNumber = printing.Number;
dbPrinting.Artist = UpsertSimpleLookup(db.Artists, printing.Artist);
dbPrinting.Watermark = UpsertSimpleLookup(db.Watermarks, printing.Watermark);
dbPrinting.Frame = UpsertSimpleLookup(db.Frames, printing.FrameVersion);
dbPrinting.Rarity = UpsertSimpleLookup(db.Rarities, printing.Rarity);
dbPrinting.Border = UpsertSimpleLookup(db.Borders, printing.BorderColor);
if (printing.Prices?.Paper != null)
{
var pricingUpsert = UpsertPricing(dbPrinting, printing.Prices.Paper, false);
result.Merge(pricingUpsert);
}
if (printing.Prices?.PaperFoil != null)
{
var pricingUpsert = UpsertPricing(dbPrinting, printing.Prices.PaperFoil, true);
result.Merge(pricingUpsert);
}
dbPrinting.Card = card.MainObject;
result.MainObject = dbPrinting;
return(result);
}
private UpsertResult <Card> UpsertCard(JsonCard printing)
{
var result = new UpsertResult <Card>();
var dbCard = db.Cards.Local
.Where(c => c.Name == printing.CockatriceName)
.SingleOrDefault();
if (dbCard == null)
{
dbCard = new Card()
{
Name = printing.CockatriceName
};
result.ObjectsToAdd.Add(dbCard);
}
dbCard.CockatriceName = printing.Name;
dbCard.ManaCost = printing.ManaCost;
dbCard.CMC = printing.ConvertedManaCost;
dbCard.TypeLine = printing.Type;
dbCard.OracleText = printing.Text ?? string.Empty;
dbCard.Power = printing.Power;
dbCard.Toughness = printing.Toughness;
dbCard.Loyalty = printing.Loyalty;
dbCard.EDHRECRank = printing.EDHRECRank;
printing.Types = printing.Types.ConvertAll(t => t.ToLower());
if (dbCard.Colors.Select(t => t.Color.Symbol).Except(printing.Colors).Any() ||
printing.Colors.Except(dbCard.Colors.Select(t => t.Color.Symbol)).Any())
{
result.ObjectsToRemove.AddRange(dbCard.Colors);
var colors = db.Colors.Where(c => printing.Colors.Contains(c.Symbol));
var cardColors = new List <CardColor>();
foreach (var color in colors)
{
cardColors.Add(new CardColor()
{
Card = dbCard,
Color = color
});
}
result.ObjectsToAdd.AddRange(cardColors);
}
if (printing.Types.Contains("land") && !printing.Supertypes.Contains("Basic"))
{
if (printing.Text.Contains("plains", StringComparison.CurrentCultureIgnoreCase) && !printing.ColorIdentity.Contains("W"))
{
printing.ColorIdentity.Add("W");
}
if (printing.Text.Contains("island", StringComparison.CurrentCultureIgnoreCase) && !printing.ColorIdentity.Contains("U"))
{
printing.ColorIdentity.Add("U");
}
if (printing.Text.Contains("swamp", StringComparison.CurrentCultureIgnoreCase) && !printing.ColorIdentity.Contains("B"))
{
printing.ColorIdentity.Add("B");
}
if (printing.Text.Contains("mountain", StringComparison.CurrentCultureIgnoreCase) && !printing.ColorIdentity.Contains("R"))
{
printing.ColorIdentity.Add("R");
}
if (printing.Text.Contains("forest", StringComparison.CurrentCultureIgnoreCase) && !printing.ColorIdentity.Contains("G"))
{
printing.ColorIdentity.Add("G");
}
}
if (dbCard.ColorIdentity.Select(t => t.Color.Symbol).Except(printing.ColorIdentity).Any() ||
printing.ColorIdentity.Except(dbCard.ColorIdentity.Select(t => t.Color.Symbol)).Any())
{
result.ObjectsToRemove.AddRange(dbCard.ColorIdentity);
var colors = db.Colors.Where(c => printing.ColorIdentity.Contains(c.Symbol));
var cardColorIdentity = new List <CardColorIdentity>();
foreach (var color in colors)
{
cardColorIdentity.Add(new CardColorIdentity()
{
Card = dbCard,
Color = color
});
}
result.ObjectsToAdd.AddRange(cardColorIdentity);
}
if (dbCard.Supertypes.Select(t => t.Supertype.Name).Except(printing.Supertypes).Any() ||
printing.Supertypes.Except(dbCard.Supertypes.Select(t => t.Supertype.Name)).Any())
{
result.ObjectsToRemove.AddRange(dbCard.Supertypes);
var supertypes = db.Supertypes.Where(t => printing.Supertypes.Contains(t.Name));
var cardSupertypes = new List <CardSupertype>();
foreach (var supertype in supertypes)
{
cardSupertypes.Add(new CardSupertype()
{
Card = dbCard,
Supertype = supertype
});
}
result.ObjectsToAdd.AddRange(cardSupertypes);
}
if (dbCard.Types.Select(t => t.CardType.Name).Except(printing.Types).Any() ||
printing.Types.Except(dbCard.Types.Select(t => t.CardType.Name)).Any())
{
result.ObjectsToRemove.AddRange(dbCard.Types);
var cardTypes = db.CardTypes.Where(t => printing.Types.Contains(t.Name));
var cardCardTypes = new List <CardCardType>();
foreach (var cardType in cardTypes)
{
cardCardTypes.Add(new CardCardType()
{
Card = dbCard,
CardType = cardType
});
}
result.ObjectsToAdd.AddRange(cardCardTypes);
}
if (dbCard.Subtypes.Select(t => t.Subtype.Name).Except(printing.Subtypes).Any() ||
printing.Subtypes.Except(dbCard.Subtypes.Select(t => t.Subtype.Name)).Any())
{
result.ObjectsToRemove.AddRange(dbCard.Subtypes);
var subtypes = db.Subtypes.Where(t => printing.Subtypes.Contains(t.Name));
var cardSubtypes = new List <CardSubtype>();
foreach (var subtype in subtypes)
{
cardSubtypes.Add(new CardSubtype()
{
Card = dbCard,
Subtype = subtype
});
}
result.ObjectsToAdd.AddRange(cardSubtypes);
}
var keywords = printing.Keywords.Select(k => k.ToLower());
if (dbCard.Keywords.Select(k => k.Keyword.Name.ToLower()).Except(keywords).Any() ||
keywords.Except(dbCard.Keywords.Select(k => k.Keyword.Name.ToLower())).Any())
{
result.ObjectsToRemove.AddRange(dbCard.Keywords);
var dbKeywords = db.Keywords.Where(k => printing.Keywords.Contains(k.Name));
var cardKeywords = new List <CardKeyword>();
foreach (var keyword in dbKeywords)
{
cardKeywords.Add(new CardKeyword()
{
Card = dbCard,
Keyword = keyword
});
}
result.ObjectsToAdd.AddRange(cardKeywords);
}
dbCard.Layout = UpsertSimpleLookup(db.Layouts, printing.Layout);
var legalityUpsert = legalityHelper.UpsertLegalities(dbCard, printing.Legalities, printing.LeadershipSkills);
dbCard.Legalities = legalityUpsert.MainObject;
result.Merge(legalityUpsert);
dbCard.Side = printing.Side;
if (printing.Side == null || printing.Side == "a")
{
dbCard.MainSide = null;
}
result.MainObject = dbCard;
return(result);
}
public UpsertResult <List <Legality> > UpsertLegalities(Card card, JsonLegality legality, JsonLeadership leadership)
{
var result = new UpsertResult <List <Legality> >()
{
MainObject = new List <Legality>()
};
var brawl = this.UpsertLegality(card, "Brawl", IsLegal(legality.Brawl), IsLegal(legality.Brawl) && card.Types.Any(c => c.CardType.Name == "creature" || c.CardType.Name == "planeswalker") && card.Supertypes.Any(c => c.Supertype.Name == "Legendary"));
result.MainObject.Add(brawl.MainObject);
result.Merge(brawl);
var commander = this.UpsertLegality(card, "Commander", IsLegal(legality.Commander), legality.Commander != "Banned" && leadership.Commander);
result.MainObject.Add(commander.MainObject);
result.Merge(commander);
var duel = this.UpsertLegality(card, "Duel", IsLegal(legality.Duel), legality.Duel != "Banned" && leadership.Commander);
result.MainObject.Add(duel.MainObject);
result.Merge(duel);
var frontier = this.UpsertLegality(card, "Frontier", IsLegal(legality.Frontier), false);
result.MainObject.Add(frontier.MainObject);
result.Merge(frontier);
var historic = this.UpsertLegality(card, "Historic", IsLegal(legality.Historic), false);
result.MainObject.Add(historic.MainObject);
result.Merge(historic);
var future = this.UpsertLegality(card, "Future", IsLegal(legality.Future), false);
result.MainObject.Add(future.MainObject);
result.Merge(future);
var legacy = this.UpsertLegality(card, "Legacy", IsLegal(legality.Legacy), false);
result.MainObject.Add(legacy.MainObject);
result.Merge(legacy);
var modern = this.UpsertLegality(card, "Modern", IsLegal(legality.Modern), false);
result.MainObject.Add(modern.MainObject);
result.Merge(modern);
var pioneer = this.UpsertLegality(card, "Pioneer", IsLegal(legality.Pioneer), false);
result.MainObject.Add(pioneer.MainObject);
result.Merge(pioneer);
var pauper = this.UpsertLegality(card, "Pauper", IsLegal(legality.Pauper), legality.Commander != "Banned" && card.Types.Any(c => c.CardType.Name == "creature") && card.Printings.Any(p => p.Rarity.Name == "uncommon"));
result.MainObject.Add(pauper.MainObject);
result.Merge(pauper);
var penny = this.UpsertLegality(card, "Penny", IsLegal(legality.Penny), false);
result.MainObject.Add(penny.MainObject);
result.Merge(penny);
var standard = this.UpsertLegality(card, "Standard", IsLegal(legality.Standard), false);
result.MainObject.Add(standard.MainObject);
result.Merge(standard);
var vintage = this.UpsertLegality(card, "Vintage", IsLegal(legality.Vintage), false);
result.MainObject.Add(vintage.MainObject);
result.Merge(vintage);
string obLegality = legality.Vintage;
var OathbreakerBans = configuration.GetSection("BanLists:Oathbreaker").Get <List <string> >();
if (OathbreakerBans.Contains(card.Name))
{
obLegality = "Banned";
}
var oathbreaker = this.UpsertLegality(card, "Oathbreaker", IsLegal(obLegality), leadership.Oathbreaker);
result.MainObject.Add(oathbreaker.MainObject);
result.Merge(oathbreaker);
string tlLegality = legality.Commander;
var TinyLeadersBans = configuration.GetSection("BanLists:TinyLeaders").Get <List <string> >();
if (card.CMC > 3 || TinyLeadersBans.Contains(card.Name))
{
tlLegality = "Banned";
}
bool tlCmdrLegality = leadership.Commander;
var TinyLeadersCmdrBans = configuration.GetSection("BanLists:TinyLeadersCmdr").Get <List <string> >();
if (card.CMC > 3 || TinyLeadersCmdrBans.Contains(card.Name))
{
tlCmdrLegality = false;
}
var tinyLeaders = this.UpsertLegality(card, "TinyLeaders", IsLegal(tlLegality), tlCmdrLegality);
result.MainObject.Add(tinyLeaders.MainObject);
result.Merge(tinyLeaders);
return(result);
}
