// Build a Facade to provide a simplified API over a set of classes
// May wish to (optionally) expose internals through the facade
// May allow users to 'escalate' to use more complex APIs if they need to
public static void Demo()
{
var facade = new FacadeClass();
facade.MethodA();
facade.MethodB();
}
/// <summary>
/// Get the DataObject <em>id</em> from the FacadeClass as a dictionary of native values,
/// filtering out nulls, hidden, or unreadable fields.
/// </summary>
/// <param name="facade">The FacadeClass</param>
/// <param name="id">The prefix for the DataObject to return</param>
/// <returns>Dictionary of field names and values from the DataObject</returns>
public static Dictionary <string, object> GetDataObjectDictionary(this FacadeClass facade, string id)
{
var result = new Dictionary <string, object>();
var data = facade.GetDataObject(id);
if (data == null)
{
return(null);
}
foreach (DictionaryEntry pair in data.GetFields())
{
Field field = (Field)pair.Value;
if (field == null || field.ValueNative == null)
{
continue;
}
// Skip hidden fields
if (!field.CanSelect || field.Properties.Hidden)
{
continue;
}
result.Add((string)pair.Key, field.ValueNative);
}
return(result);
}
/// <summary>
/// Copy the values from <em>update</em> to the named fields on the <em>facade</em>,
/// skipping hidden, readyonly, and otherwise noneditable fields
/// </summary>
/// <param name="facade">The FacadeClass to copy the values onto.</param>
/// <param name="update">The JSON object to read values from.</param>
public static void Merge(this FacadeClass facade, JObject update)
{
foreach (var pair in update)
{
var token = pair.Value;
var field = facade.GetField(pair.Key);
// Make sure the field exists
if (field == null)
{
continue;
}
// Skip read-only fields
if (!field.CanUpdate || field.Properties.ReadOnly || field.Properties.ReadOnlyEdit || field.Properties.NotEditable)
{
continue;
}
// Make sure its a scalar type
if (token is JValue jvalue)
{
field.ValueNative = jvalue.Value;
}
}
}
public static void TestFacade()
{
Console.WriteLine("-- TEST FACADE --");
FacadeClass.FacadeMethodA();
FacadeClass.FacadeMethodB();
FacadeClass.FacadeMethodWorkerVariant();
}
private void MainForm_Load(object sender, EventArgs e)
{
main = this;
FacadeClass facade = new FacadeClass();
facade.displayInfo();
facade.displayItems();
}
public override void Upgrade()
{
base.Upgrade();
FacadeClass <ItemDataFile> facadeClass = new FacadeClass <ItemDataFile>();
ItemDataFile data = facadeClass.ParseJson("itemGeneration/Armors");
echantements.Add(data.enchantements[Random.Range(0, data.enchantements.Length)]);
}
// GET: Facade
public ActionResult Index()
{
FacadeClass facade = new FacadeClass();
facade.Tasks1();
facade.Tasks3();
return(View());
}
// GET api/<controller>
public IEnumerable <Hashtable> Get()
{
// Make sure the user is logged in
if (CustomerKey == null || Individual == null || string.IsNullOrEmpty(Individual.CurrentKey))
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
// This could be passed in via a query string (compared against a whitelist), or derived from the object model
var columns = new string[] { "cst_recno", "ind_first_name", "ind_last_name", "ind_badge_name", "eml_address", "adr_city", "adr_line1", "adr_post_code", "adr_state" };
// Using a real data model is preferable
var result = new List <Hashtable>();
using (FacadeClass facade = FacadeObjectFactory.CreateIndividual()) // Re-use the facade to reduce memory usage
using (var connection = DataUtils.GetConnection())
using (var transaction = connection.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted))
// In a real-world application, you wouldn't dump your whole database
// Ideally a high-level filter would be applied (i.e. adr_state in this case), with pagination
// Any more specific filtering (city, zip, radius) could be done client-side
// Adding a caching mechanism would increase performance
using (var cmd = new NfDbCommand(@"
SELECT
ind_cst_key
FROM
co_customer (NOLOCK)
JOIN co_individual (NOLOCK) ON ind_cst_key = cst_key AND ind_delete_flag = 0
WHERE
cst_delete_flag = 0
", connection, transaction))
using (var reader = cmd.ExecuteReader())
{
while (reader.HasRows && reader.Read())
{
facade.CurrentKey = ((Guid)reader.GetValue(0)).ToString();
facade.SelectByKey(connection, transaction);
// Using a real data model is preferable
var record = new Hashtable();
foreach (var col in columns)
{
// Using GetValueNative so booleans and numeric data types come over to JSON as their proper data types
record[col] = facade.GetValueNative(col);
}
result.Add(record);
// Clear facade values between loop iterations
facade.ClearValues();
}
}
return(result);
}
public static void Main(string[] Args)
{
var apiPath = Path.GetFullPath(@"C:\Users\maxi\Documents\SharpDevelop Projects\Project Hedra\Hedra/api.json");
var apiFolder = Path.GetDirectoryName(apiPath);
var configuration = Configuration.Load(apiPath);
if (configuration == null)
{
throw new ArgumentException("Configuration file is invalid.");
}
FacadeClass.Namespace = configuration.TargetNamespace;
for (var i = 0; i < configuration.Folders.Length; i++)
{
var folderPath = configuration.Folders[i].Path;
var excludeList = configuration.Folders[i].ExcludeClasses;
var includeList = configuration.Folders[i].IncludeClasses;
var files = Directory.GetFiles(apiFolder + folderPath);
for (var k = 0; k < files.Length; k++)
{
if (!Path.GetExtension(files[k])?.EndsWith(".cs") ?? true)
{
continue;
}
if (excludeList != null && excludeList.Any(C => C.Name == Path.GetFileName(files[k])))
{
continue;
}
var any = includeList?.FirstOrDefault(C => C.Name == Path.GetFileName(files[k]));
if (includeList != null && any == null)
{
continue;
}
var facadeClass = any == null
? FacadeClass.Build(File.ReadAllText(files[k]))
: FacadeClass.Build(File.ReadAllText(files[k]), any);
if (facadeClass == null)
{
continue;
}
var writer = (FacadeClassWriter)Activator.CreateInstance(ClassWriters[facadeClass.Type], facadeClass);
var newFolders = string.Join("/", FacadeClass.Namespace.Split('.').Where(S => S != Path.GetFileNameWithoutExtension(apiFolder)));
Directory.CreateDirectory($"{apiFolder}/{newFolders}");
File.WriteAllText($"{apiFolder}/{newFolders}/{Path.GetFileName(files[k])}", writer.Build());
Console.WriteLine($"Writing {facadeClass.Type} class '{newFolders}/{Path.GetFileName(files[k])}'...");
}
}
}
private JObject GetFields(FacadeClass individual)
{
var fields = new JObject();
foreach (var column in new string[] { "cst_key", "ind_first_name", "ind_last_name", "ind_badge_name", "eml_address", "cxa_mailing_label" })
{
var field = individual.GetField(column);
if (field != null)
{
fields[column] = field.ValueNative;
}
}
return(fields);
}
private JObject GetFields(FacadeClass membership)
{
var fields = new JObject();
foreach (var column in new string[] { "mbr_key", "mbr_asn_code", "mbt_key", "mbt_code", "mbr_cst_key", "mbr_auto_pay", "mbr_cpi_key" })
{
var field = membership.GetField(column);
if (field != null)
{
fields[column] = field.ValueNative;
}
}
return(fields);
}
public FacadeAbstractMethodWriter(FacadeClass Class, FacadeMethod Method) : base(Class, Method)
{
}
public FacadeNormalClassWriter(FacadeClass Class) : base(Class)
{
}
public DirectoryController() : base()
{
CustomerKey = this.GetCustomerKey();
Individual = this.GetIndividual();
}
public FacadeStaticMethodWriter(FacadeClass Class, FacadeMethod Method) : base(Class, Method)
{
}
public ExportService(string formKey, FacadeClass facadeObject, ExportMode exportMode)
{
_formKey = formKey;
_facadeObject = facadeObject;
_exportMode = exportMode;
}
protected FacadeClassWriter(FacadeClass Class)
{
this.Class = Class;
this.Writer = new FacadeStringWriter();
}
public FacadeNormalMethodWriter(FacadeClass Class, FacadeMethod Method) : base(Class, Method)
{
}
public FacadeSealedClassWriter(FacadeClass Class) : base(Class)
{
}
protected FacadeMethodWriter(FacadeClass Class, FacadeMethod Method)
{
this.Class = Class;
this.Method = Method;
}
public FacadeStaticClassWriter(FacadeClass Class) : base(Class)
{
}
public FacadeAbstractClassWriter(FacadeClass Class) : base(Class)
{
}
public FacadeConstructorWriter(FacadeClass Class, FacadeMethod Method) : base(Class, Method)
{
}
