public AzureServiceClientTemplateModel(ServiceClient serviceClient) : base(serviceClient)
{
MethodTemplateModels.Clear();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient)));
// Removing all models that contain the extension "x-ms-external", as they will be
// generated in python client runtime for azure - "ms-rest-azure".
ModelTemplateModels.Clear();
ModelTypes.ForEach(m => ModelTemplateModels.Add(new AzureModelTemplateModel(m, serviceClient)));
ModelTemplateModels.RemoveAll(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension));
ModelTemplateModels.RemoveAll(m => m.Extensions.ContainsKey(AzureExtensions.ExternalExtension));
HasAnyModel = false;
if (serviceClient.ModelTypes.Any())
{
foreach (var model in serviceClient.ModelTypes)
{
if (!model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) || !(bool)model.Extensions[AzureExtensions.ExternalExtension])
{
HasAnyModel = true;
break;
}
}
}
}
public async Task <IActionResult> Index(ModelTypes model)
{
List <WW2Item> items = new List <WW2Item>();
switch (model)
{
case ModelTypes.Land:
items = await context.Items.Where(x => x.Type == ModelTypes.Land).ToListAsync();
break;
case ModelTypes.Sea:
items = await context.Items.Where(x => x.Type == ModelTypes.Sea).ToListAsync();
break;
case ModelTypes.Air:
items = await context.Items.Where(x => x.Type == ModelTypes.Air).ToListAsync();
break;
default:
break;
}
return(View(items));
}
public void TestJsonDeserialize()
{
var serializer = new Serializer();
foreach (var type in modelTypes)
{
var method = serializer
.GetType()
.GetMethod("JsonDeserialize")
.MakeGenericMethod(type);
var filename = $"objects/{ModelTypes.NameFor(type)}_object.json";
if (!TestData.Files.ContainsKey(filename))
{
throw new FileNotFoundException(filename);
}
var filedata = TestData.Files[filename];
object result;
using (var ms = new MemoryStream(filedata)) {
result = method.Invoke(serializer, new object[] { ms });
}
Assert.IsInstanceOf(type, result);
}
}
public Test_Binder()
{
// We need to make sure all generated entity
// classes have been registered.
ModelTypes.Register();
}
/// <summary>
///
/// </summary>
/// <param name="DataTypeA"></param>
/// The first part of the composite key
/// <param name="DataTypeB"></param>
/// THe second part of the composite key
/// <param name="TrueDataType"></param>
/// The actual DataType in use
public void Init_Composite(ModelTypes DataTypeA, ModelTypes DataTypeB, ModelTypes TrueDataType)
{
IsComposit = true;
ItemIdentitySQL = $"{DataTypeA}Id =";
ItemIdentitySQLExtra = $"{DataTypeB}Id =";
init(TrueDataType);
}
/// <summary>Constructor.</summary>
/// <param name="s">Stream to parse</param>
public Reader(Stream s)
{
validModelTypes = ModelTypes.GetModelTypes();
XmlDocument doc = new XmlDocument();
doc.Load(s);
reader = new ReadWithLookAhead(new XmlNodeReader(doc.DocumentElement));
currentState = States.Initial;
}
public AzureFluentServiceClientTemplateModel(ServiceClient serviceClient)
: base(serviceClient)
{
MethodTemplateModels.Clear();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new AzureFluentMethodTemplateModel(m, serviceClient)));
ModelTemplateModels.Clear();
ModelTypes.ForEach(m => ModelTemplateModels.Add(new AzureFluentModelTemplateModel(m, serviceClient)));
}
public ServiceClientTemplateModel(ServiceClient serviceClient)
{
this.LoadFrom(serviceClient);
MethodTemplateModels = new List <MethodTemplateModel>();
ModelTemplateModels = new List <ModelTemplateModel>();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient)));
ModelTypes.ForEach(m => ModelTemplateModels.Add(new ModelTemplateModel(m, serviceClient)));
}
public AzureServiceClientTemplateModel(ServiceClient serviceClient)
: base(serviceClient)
{
Properties.Remove(Properties.Find(p => p.Type.Name == "ServiceClientCredentials"));
MethodTemplateModels.Clear();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient)));
ModelTemplateModels.Clear();
ModelTypes.ForEach(m => ModelTemplateModels.Add(new AzureModelTemplateModel(m, serviceClient)));
}
public void Test_No_Duplicate_OpCodes_For_Same_PayloadType()
{
//arrange
IEnumerable <Type> distinctPayloads = ModelTypes
.Where(t => t.GetCustomAttribute <GamePayloadAttribute>(true) != null)
.Distinct(new PayloadTypeEqualityComparerByOpCodeAndType())
.ToArray();
//assert
Assert.AreEqual(ModelTypes.Count(t => t.GetCustomAttribute <GamePayloadAttribute>(true) != null), distinctPayloads.Count(), $"Encountered duplicate payload type More than 1 payload shares same OpCode and BaseType. Violating Types: {ModelTypes.Where(t => t.GetCustomAttribute<GamePayloadAttribute>(true) != null).Except(distinctPayloads).Aggregate("", (s, type) => $"{s} {type.Name}:OpCode.{type.GetCustomAttribute<GamePayloadAttribute>(true).OperationCode}")}");
}
public ServiceClientTemplateModel(ServiceClient serviceClient)
{
this.LoadFrom(serviceClient);
MethodTemplateModels = new List <MethodTemplateModel>();
ModelTemplateModels = new List <ModelTemplateModel>();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient)));
ModelTypes.ForEach(m => ModelTemplateModels.Add(new ModelTemplateModel(m, serviceClient)));
this.IsCustomBaseUri = serviceClient.Extensions.ContainsKey(Microsoft.Rest.Generator.Extensions.ParameterizedHostExtension);
}
public IEnumerable <Action> Compare(IEnumerable <TableInfo> schemaTables, IEnumerable <ColumnInfo> schemaColumns)
{
List <Action> results = new List <Action>();
if (CommandProvider.SupportsSchemas)
{
var createSchemas = GetNewSchemas(ModelTables, schemaTables);
results.AddRange(createSchemas.Select(s => new CreateSchema(s)));
}
var createTables = GetNewTables(ModelTables, schemaTables);
results.AddRange(createTables.Select(tbl => new CreateTable(tbl.ModelType)));
// when looking for modified columns, don't include tables that were just created
var existingModelColumns = ModelColumns.Where(col => !createTables.Contains(col.TableInfo));
var schemaColumnsByTable = schemaColumns.ToLookup(row => row.TableInfo);
var modelColumnsByTable = existingModelColumns.ToLookup(row => row.TableInfo);
var tablesToTypes = ModelTypes.ToDictionary(t => CommandProvider.GetTableInfo(t));
foreach (TableInfo tbl in schemaColumnsByTable)
{
if (AnyModifiedColumns(schemaColumnsByTable[tbl], modelColumnsByTable[tbl],
out IEnumerable <ColumnInfo> added, out IEnumerable <ColumnInfo> modified, out IEnumerable <ColumnInfo> deleted))
{
if (tbl.RowCount == 0)
{
// empty tables can be dropped and re-created
results.Add(new RebuildTable(tablesToTypes[tbl], added, modified, deleted));
}
else
{
// must modify columns directly
results.AddRange(added.Select(a => new AddColumn(a)));
results.AddRange(deleted.Select(d => new DropColumn(d)));
results.AddRange(modified.Select(m => new AlterColumn(m)));
}
}
}
//var addColumns = await GetNewColumnsAsync(ModelTypes, createTables.Concat(rebuiltTables), connection);
//results.AddRange(addColumns.Select(pi => new AddColumn(pi)));
var dropTables = GetDeletedTables(ModelTables, schemaTables);
results.AddRange(dropTables.Select(tbl => new DropTable(tbl)));
var newForeignKeys = ModelColumns.Where(col => createTables.Contains(col.TableInfo) && col.IsForeignKey);
results.AddRange(newForeignKeys.Select(col => new AddForeignKey(col.ForeignKeyInfo)));
return(results);
}
public Model(ModelTypes kind, string name = "", Model parent = null)
{
this.Kind = new ModelKind(kind);
this.Name = name;
this.Parent = parent;
this.Completed = false;
Properties = new PropertyCollection();
Properties.Add(new Property(Vs.Properties.NAME));
Properties.Add(new Property(Vs.Properties.KIND));
}
public GenericModel GetModel(ModelTypes type)
{
if (_models.Exists(x => x.Type == type))
{
return(_models.Find(x => x.Type == type));
}
else
{
Debug.LogError("Model not founded " + type);
return(null);
}
}
public async Task <List <T> > GetFiltered(ModelTypes joinId, ModelTypes klassId = ModelTypes.None)
{
if (klassId == ModelTypes.None)
{
await SQLCommand(SQLType.JoinOn, $"{joinId}.{joinId}");
}
else
{
await SQLCommand(SQLType.JoinOn, $"{klassId}.{joinId}");
}
return(Items);
}
public string ConstructServiceClientJSExports()
{
StringBuilder builder = new StringBuilder();
builder.AppendLine($"module.exports = {Name};");
builder.AppendLine($"module.exports['default'] = {Name};");
builder.AppendLine($"module.exports.{Name} = {Name};");
if (ModelTypes.Any())
{
builder.AppendLine($"module.exports.{ServiceModelsName} = models;");
}
return(builder.ToString());
}
private object MyRead(ModelTypes readModel)
{
switch (readModel)
{
case ModelTypes.Conference:
return(Maker_Conference());
case ModelTypes.Enrollment:
return(Maker_Enrollment());
case ModelTypes.Event:
return(Maker_Event());
case ModelTypes.Floor:
return(Maker_Floor());
case ModelTypes.Room:
return(Maker_Room());
case ModelTypes.Speaker:
return(Maker_Speaker());
case ModelTypes.User:
return(Maker_User());
case ModelTypes.Venue:
return(Maker_Venue());
case ModelTypes.SeatCategory:
return(Maker_SeatCategory());
case ModelTypes.Theme:
return(Maker_Theme());
case ModelTypes.Feature:
return(Maker_Feature());
case ModelTypes.RoomFeature:
return(Maker_RoomFeature());
case ModelTypes.EventTheme:
return(Maker_EventTheme());
case ModelTypes.SeatCategoryTaken:
return(Maker_SeatCategoryTaken());
case ModelTypes.UserConferenceBinding:
return(Maker_UserConferenceBinding());
}
return(null);
}
public IMobile GetMobile(ModelTypes modelTypes)
{
switch (modelTypes)
{
case ModelTypes.AppleIphone12:
return(new AppleIphone12());
case ModelTypes.AppleIphone12Pro:
return(new AppleIphone12Pro());
default:
throw new Exception("Invalid model type");
}
}
public IMobile GetMobile(ModelTypes modelTypes)
{
switch (modelTypes)
{
case ModelTypes.Onplus8:
return(new Oneplus8());
case ModelTypes.OneplusNord:
return(new OneplusNord());
default:
throw new Exception("Invalid model type");
}
}
public ActionResult Create(FormCollection collection)
{
try
{
// TODO: Add insert logic here
var model = new ModelTypes();
TryUpdateModel(model);
model.Insert();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Edit(int id, FormCollection collection)
{
try
{
// TODO: Add update logic here
var model = ModelTypes.GetById(id);
TryUpdateModel(model);
model.SaveOrUpDate();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public List <T> OnRead <T>(ModelTypes model, SqlDataReader sqlReader)
{
_reader = sqlReader;
List <T> models = new List <T>();
while (_reader.Read())
{
T obj = (T)MyRead(model);
if (obj == null)
{
return(new List <T>());
}
models.Add(obj);
}
return(models);
}
public async Task <DeleteResult> DeleteAsync(int id, ModelTypes modelType)
{
try
{
if (modelType == ModelTypes.AreaModel)
{
return(await _areaC.DeleteOneAsync(Builders <AreaModel> .Filter.Eq(s => s.Id, id)));
}
else if (modelType == ModelTypes.ShipModel)
{
return(await _shipC.DeleteOneAsync(Builders <ShipModel> .Filter.Eq(s => s.Id, id)));
}
else if ((modelType == ModelTypes.PlayerModel))
{
return(await _playerC.DeleteOneAsync(Builders <PlayerModel> .Filter.Eq(s => s.Id, id)));
}
else if ((modelType == ModelTypes.AccountModel))
{
return(await _accountC.DeleteOneAsync(Builders <AccountModel> .Filter.Eq(s => s.Id, id)));
}
else if (modelType == ModelTypes.StructureModel)
{
return(await
_structureC.DeleteOneAsync(Builders <IStructureModel> .Filter.Eq <int>("_id", id)));
}
else if (modelType == ModelTypes.TeamModel)
{
return(await _teamC.DeleteOneAsync(Builders <TeamModel> .Filter.Eq(s => s.Id, id)));
}
else if (modelType == ModelTypes.TradeRecordModel)
{
return(await _tradeRecordModelC.DeleteOneAsync(Builders <TradeRecordModel> .Filter.Eq(s => s.Id, id)));
}
else
{
throw new Exception("Error: Database deletion not available for objects of type " + modelType);
}
}
catch (Exception e)
{
ConsoleManager.WriteLine("Exception in " + this + ": " + e.Message, ConsoleMessageType.Error);
ConsoleManager.WriteLine(e.StackTrace, ConsoleMessageType.Error);
return(DeleteResult.Unacknowledged.Instance);
}
}
public ServiceClientTemplateModel(ServiceClient serviceClient)
{
this.LoadFrom(serviceClient);
MethodTemplateModels = new List <MethodTemplateModel>();
ModelTemplateModels = new List <ModelTemplateModel>();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient)));
ModelTypes.ForEach(m => ModelTemplateModels.Add(new ModelTemplateModel(m, serviceClient)));
this.IsCustomBaseUri = serviceClient.Extensions.ContainsKey(SwaggerExtensions.ParameterizedHostExtension);
// Default scheme when there's none
if (!BaseUrl.Contains("://"))
{
BaseUrl = string.Format(CultureInfo.InvariantCulture, "https://{0}", BaseUrl);
}
}
private void OnBrowseClicked(object sender, RoutedEventArgs e)
{
if (Module.ModelTypes == null)
{
return;
}
ModelTypes selected = null;
foreach (ModelTypes modelType in Module.ModelTypes)
{
if (modelType.Id == this.ModelType)
{
selected = modelType;
}
}
SelectorDrawer.Show <ModelTypeSelector, ModelTypes>("Model Type", selected, (v) => { this.ModelType = v.Id; });
}
public ServiceClientTemplateModel(ServiceClient serviceClient)
{
this.LoadFrom(serviceClient);
MethodTemplateModels = new List <MethodTemplateModel>();
ModelTemplateModels = new List <ModelTemplateModel>();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient)));
ModelTypes.ForEach(m => ModelTemplateModels.Add(new ModelTemplateModel(m, serviceClient)));
ServiceClient = serviceClient;
this.Version = this.ApiVersion;
this.HasAnyModel = false;
if (ModelTemplateModels.Any())
{
this.HasAnyModel = true;
}
ConstantProperties = Properties.Where(p => p.IsConstant).ToList();
Properties.RemoveAll(p => ConstantProperties.Contains(p));
this.IsCustomBaseUri = serviceClient.Extensions.ContainsKey(SwaggerExtensions.ParameterizedHostExtension);
}
internal void Deserialize(SortedDictionary <Guid, GMResourceInfoModel> projectResources)
{
if (projectResources == null)
{
throw new ArgumentNullException(nameof(projectResources));
}
// TODO Please find a more memory effecient way to do this
var models = new List <ModelBase>(projectResources.Count);
foreach (var kvp in projectResources)
{
var id = kvp.Key;
var info = kvp.Value;
Tuple <Type, Type> modelType;
if (!ModelTypes.TryGetValue(info.resourceType, out modelType))
{
throw new InvalidOperationException($"Cannot deserialize unknown resource model '{info.resourceType}'");
}
// TODO Optimize
var resource = (GMResource)Activator.CreateInstance(modelType.Item1);
resource.Project = project;
resource.ResourceInfoId = info.id;
resource.Id = id;
var fullPath = Path.Combine(project.RootDirectory, info.resourcePath);
var model = (ModelBase)Utility.Json.Deserialize(modelType.Item2, fullPath);
resource.Deserialize(model);
resources.Add(resource.Id, resource);
models.Add(model);
}
foreach (var model in models)
{
resources[model.id].FinalizeDeserialization(model);
}
}
public async Task <IEnumerable <IDBObject> > GetHandoffModelsAsync(ModelTypes modelType)
{
switch (modelType)
{
case ModelTypes.ShipModel:
{
var res = await _handedOffShips.FindAsync(Builders <ShipModel> .Filter.Empty);
return(res.ToList());
}
case ModelTypes.PlayerModel:
{
var res = await _handedOffPlayers.FindAsync(Builders <PlayerModel> .Filter.Empty);
return(res.ToList());
}
default:
{
throw new InvalidOperationException("Handoff database not available for Model Type " + modelType);
}
}
}
public async Task <DeleteResult> DeleteAsync(string id, ModelTypes modelType)
{
try
{
if ((modelType == ModelTypes.PlanetLayout))
{
return(await _layoutC.DeleteOneAsync(Builders <PlanetLayout> .Filter.Eq(s => s.LayoutName, id)));
}
else if (modelType == ModelTypes.ShipStats)
{
return(await _shipStatsC.DeleteOneAsync(Builders <ShipStats> .Filter.Eq(s => s.ShipType.ToString(), id)));
}
else
{
throw new Exception("Error: Database deletion not available for objects of type " + modelType);
}
}
catch (Exception e)
{
ConsoleManager.WriteLine("Exception in " + this + ": " + e.Message, ConsoleMessageType.Error);
ConsoleManager.WriteLine(e.StackTrace, ConsoleMessageType.Error);
return(DeleteResult.Unacknowledged.Instance);
}
}
public async Task <DeleteResult> HandoffDeleteAsync(int id, ModelTypes modelType)
{
switch (modelType)
{
case ModelTypes.ShipModel:
{
var filt = Builders <ShipModel> .Filter.Eq(s => s.Id, id);
return(await _handedOffShips.DeleteOneAsync(filt));
}
case ModelTypes.PlayerModel:
{
var filt = Builders <PlayerModel> .Filter.Eq(p => p.Id, id);
return(await _handedOffPlayers.DeleteOneAsync(filt));
}
default:
{
throw new Exception("Error: Handoff deletion not available for objects of type " + modelType);
}
}
}
ImageModalModel GetModalModel(int id, ModelTypes type)
{
var model = new ImageModalModel();
model.PackageList = Manager.Packages.Items.Where(p => p.UserID == Security.User.ID).OrderByDescending(p => p.ID).ToArray();
switch (type)
{
case ModelTypes.Resave:
{
var image = Manager.Images.Find(id);
if (image != null)
{
model.ID = image.ID;
model.PackageID = model.PackageList.Select(p => p.ID).FirstOrDefault();
model.ImagePath = new ImageInfo(image).ThumbFW236.Url;
model.Description = image.Description;
}
break;
}
case ModelTypes.Add:
{
var file = Manager.Files.Find(id);
model.ImagePath = new ImageInfo(new Image { File = file }).ThumbFW236.Url;
model.PackageID = model.PackageList.Select(p => p.ID).FirstOrDefault();
break;
}
case ModelTypes.Edit:
{
var image = Manager.Images.Find(id);
model.ImagePath = new ImageInfo(image).ThumbFW236.Url;
model.Description = image.Description;
model.PackageID = image.PackageID;
break;
}
default:
break;
}
return model;
}
/// <summary>Constructor.</summary>
public TableEntitiesTemplate()
{
ModelTypes = new ModelTypes();
}
public void TestSetup()
{
modelTypes = new ModelTypes();
}
