/// <summary> /// Creates an object that translates the parameters used for external methods to parameters for internal methods. /// </summary> public DestroyParameterMatrix(TableSchema tableSchema) { // Initialize the object. this.ExternalParameterItems = new SortedList <string, ExternalParameterItem>(); // Every set of update parameters requires a unique key to identify the record that is to be updated. UniqueConstraintParameterItem primaryKeyParameterItem = new UniqueConstraintParameterItem(); primaryKeyParameterItem.ActualDataType = typeof(Object[]); primaryKeyParameterItem.DeclaredDataType = typeof(Object[]); primaryKeyParameterItem.Description = String.Format("The required key for the {0} table.", tableSchema.Name); primaryKeyParameterItem.FieldDirection = FieldDirection.In; primaryKeyParameterItem.Name = String.Format("{0}Key", CommonConversion.ToCamelCase(tableSchema.Name)); this.ExternalParameterItems.Add(primaryKeyParameterItem.Name, primaryKeyParameterItem); // This will create an interface for the 'Destroy' method. foreach (KeyValuePair <string, ColumnSchema> columnPair in tableSchema.Columns) { // This column is turned into a simple parameter. ColumnSchema columnSchema = columnPair.Value; // The row version is required for the optimistic concurrency checking that is part of all update operations. if (columnSchema.IsRowVersion) { SimpleParameterItem simpleParameterItem = new SimpleParameterItem(); simpleParameterItem.ActualDataType = columnSchema.DataType; simpleParameterItem.ColumnSchema = columnSchema; simpleParameterItem.DeclaredDataType = columnSchema.DataType; simpleParameterItem.Description = String.Format("The required value for the {0} column.", CommonConversion.ToCamelCase(columnSchema.Name)); simpleParameterItem.FieldDirection = FieldDirection.In; simpleParameterItem.Name = CommonConversion.ToCamelCase(columnSchema.Name); this.ExternalParameterItems.Add(simpleParameterItem.Name, simpleParameterItem); } } }
/// <summary> /// A private field used to hold a complex filtering algorithm. /// </summary> public ComplexFilterField(WhereSchema whereSchema) { // private ComplexFilter<Sandbox.WorkingOrder.WorkingOrder> filter; this.Attributes = MemberAttributes.Private; this.Type = new CodeTypeReference(string.Format("FluidTrade.Core.ComplexFilter<{0}>", whereSchema.ResultType)); this.Name = CommonConversion.ToCamelCase(whereSchema.Predicate); }
/// <summary> /// Show an exeption alert /// </summary> /// <param name="recordNotFoundException"></param> public void Show(FaultException <RecordNotFoundFault> recordNotFoundException) { Display(String.Format(FluidTrade.Core.Properties.Resources.RecordNotFoundError, CommonConversion.FromArray(recordNotFoundException.Detail.Key), recordNotFoundException.Detail.TableName), AlertMessageBoxType.RecordNotFoundError); }
public ReductionRecord GetReduction(byte[] reducedCompositionHash) { var reducedCompositionHashBase16 = CommonConversion.StringBase16FromByteArray(reducedCompositionHash); var filePath = Path.Combine(ReductionDirectoryPath, reducedCompositionHashBase16); if (!File.Exists(filePath)) { return(null); } var reductionRecordFromFile = JsonConvert.DeserializeObject <ReductionRecordInFile>( File.ReadAllText(filePath, Encoding.UTF8)); if (reducedCompositionHashBase16 != reductionRecordFromFile.ReducedCompositionHashBase16) { throw new Exception("Unexpected content in file " + filePath + ", composition hash does not match."); } return(new ReductionRecord { ReducedCompositionHash = reducedCompositionHash, ReducedValueLiteralString = reductionRecordFromFile.ReducedValue?.LiteralString, }); }
private SyntaxNode GetRewrittenCollection( SyntaxGenerator generator, SyntaxNode collection, ITypeSymbol iterationVariableType, CommonConversion conversion) { if (conversion.Exists && conversion.IsReference) { // for a reference cast we can insert `.Cast<DestType>()` return(generator.InvocationExpression( generator.MemberAccessExpression( collection, generator.GenericName( nameof(Enumerable.Cast), new[] { iterationVariableType })))); } else { // otherwise we need to ensure a language specific conversion by emitting the conversion into the code // like so: `.Select(v => (DestType)v)` return(generator.InvocationExpression( generator.MemberAccessExpression( collection, generator.IdentifierName(nameof(Enumerable.Select))), generator.ValueReturningLambdaExpression( "v", generator.ConvertExpression(iterationVariableType, generator.IdentifierName("v"))))); } }
public CodeColumnExpressionCollection(ColumnSchema[] columns) { foreach (ColumnSchema columnSchema in columns) { this.Add(new CodeArgumentReferenceExpression(CommonConversion.ToCamelCase(columnSchema.Name))); } }
public List <ExpressBagNumberReport> GetBagNumberReportObj(int bagId, int userId) { List <ExpressBagNumberReport> list = new List <ExpressBagNumberReport>(); ExpressBagNumberReport reportObj = new ExpressBagNumberReport(); var bag = dbContext.ExpressBags.Find(bagId); if (bag != null) { if (!string.IsNullOrEmpty(bag.BagNumber)) { var arr = bag.BagNumber.Split('-'); if (arr.Count() > 0 && arr.Count() == 3) { reportObj.Hub = arr[0]; reportObj.Carrier = arr[1]; reportObj.BagCount = arr[1] + "/" + arr[2]; } var manifest = dbContext.ExpressManifests.Find(bag.ManifestId); if (manifest != null) { reportObj.TradelaneShipmentId = manifest.TradelaneShipmentId.HasValue ? manifest.TradelaneShipmentId.Value : 0; } reportObj.Ref = CommonConversion.GetNewFrayteNumber(); list.Add(reportObj); } } return(list); }
/// <summary> /// Generates the method used to handle the Row Changed event. /// </summary> public FilterRowMethod(TableSchema tableSchema) { // /// <summary> // /// Filters a row from the results returned to a client. // /// </summary> // /// <param name="dataModelTransaction">The transaction in which this filter takes place.</param> // /// <param name="filterContext">A general purpose context for the read operation.</param> // /// <param name="containerContext">The Entity which contains this objects and maps to an ACL entry.</param> // /// <returns>True if the given row can be returned to the client, false otherwise.</returns> // private bool FilterRow(object context, object[] transactionLogItem) // { this.Comments.Add(new CodeCommentStatement("<summary>", true)); this.Comments.Add(new CodeCommentStatement("Filters a row from the results returned to a client.", true)); this.Comments.Add(new CodeCommentStatement("</summary>", true)); this.Comments.Add(new CodeCommentStatement("<param name=\"dataModelTransaction\">The transaction in which this filter takes place.</param>", true)); this.Comments.Add(new CodeCommentStatement("<param name=\"filterContext\">A general purpose context for the read operation.</param>", true)); this.Comments.Add(new CodeCommentStatement("<param name=\"containerContext\">The Entity which contains this objects and maps to an ACL entry.</param>", true)); this.Attributes = MemberAttributes.Private | MemberAttributes.Final; this.ReturnType = new CodeGlobalTypeReference(typeof(Boolean)); this.Name = "FilterRow"; this.Parameters.Add( new CodeParameterDeclarationExpression( new CodeGlobalTypeReference(typeof(FluidTrade.Core.IDataModelTransaction)), string.Format("{0}Transaction", CommonConversion.ToCamelCase(tableSchema.DataModel.Name)))); this.Parameters.Add(new CodeParameterDeclarationExpression(new CodeGlobalTypeReference(typeof(Object)), "filterContext")); this.Parameters.Add(new CodeParameterDeclarationExpression(new CodeGlobalTypeReference(typeof(Object)), "containerContext")); // return true; this.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true))); // } }
/// <summary> /// A private field used to hold a complex sorting algorithm. /// </summary> public ComplexComparerField(OrderBySchema orderBySchema) { // private ComplexComparer<Sandbox.WorkingOrder.WorkingOrder> comparer; this.Attributes = MemberAttributes.Private; this.Type = new CodeTypeReference(string.Format("FluidTrade.Core.ComplexComparer<{0}>", orderBySchema.ResultType)); this.Name = CommonConversion.ToCamelCase(orderBySchema.Comparer); }
static PersistentProcessWithHistoryOnFileFromElm019Code BuildPersistentProcess(IServiceProvider services) { var logger = services.GetService <ILogger <Startup> >(); var elmAppFiles = services.GetService <WebAppConfiguration>()?.ElmAppFiles; if (!(0 < elmAppFiles?.Count)) { logger.LogInformation("Found no ElmAppFile in configuration."); return(null); } var elmAppComposition = Composition.FromTree( Composition.TreeFromSetOfBlobsWithStringPath(elmAppFiles, System.Text.Encoding.UTF8)); logger.LogInformation("Begin to build the persistent process for Elm app " + CommonConversion.StringBase16FromByteArray(Composition.GetHash(elmAppComposition))); var persistentProcess = new PersistentProcessWithHistoryOnFileFromElm019Code( services.GetService <ProcessStore.IProcessStoreReader>(), elmAppFiles, logger: logEntry => logger.LogInformation(logEntry)); logger.LogInformation("Completed building the persistent process."); return(persistentProcess); }
/// <summary> /// A private field used to hold a complex sorting algorithm. /// </summary> public SelectField(SelectSchema selectSchema) { // private ComplexComparer<Sandbox.WorkingOrder.WorkingOrder> comparer; this.Attributes = MemberAttributes.Private; this.Type = new CodeTypeReference(string.Format("System.Func<{0}, {1}>", selectSchema.SourceType, selectSchema.ResultType)); this.Name = CommonConversion.ToCamelCase(selectSchema.Selector); }
BuildConfigurationZipArchiveFromPath(string sourcePath) { var loadCompositionResult = LoadComposition.LoadFromPathResolvingNetworkDependencies(sourcePath) .LogToActions(Console.WriteLine); if (loadCompositionResult?.Ok == null) { throw new Exception("Failed to load from path '" + sourcePath + "': " + loadCompositionResult?.Err); } var sourceTree = loadCompositionResult.Ok.tree; /* * TODO: Provide a better way to avoid unnecessary files ending up in the config: Get the source files from git. */ var filteredSourceTree = loadCompositionResult.Ok.origin?.FromLocalFileSystem != null ? RemoveNoiseFromTreeComingFromLocalFileSystem(sourceTree) : sourceTree; var filteredSourceComposition = Composition.FromTreeWithStringPath(filteredSourceTree); var filteredSourceCompositionId = CommonConversion.StringBase16FromByteArray(Composition.GetHash(filteredSourceComposition)); Console.WriteLine("Loaded source composition " + filteredSourceCompositionId + " from '" + sourcePath + "'."); var configZipArchive = BuildConfigurationZipArchive(sourceComposition: filteredSourceComposition); return(sourceTree, filteredSourceCompositionId, configZipArchive); }
/// <summary> /// An internal vector field. /// </summary> public SchemaVectorField(PropertySchema propertySchema) { // internal System.Collections.Generic.IEnumerable<Sandbox.WorkingOrder.WorkingOrder> workingOrderList; this.Attributes = MemberAttributes.Assembly; this.Type = new CodeTypeReference(string.Format("{0}[]", propertySchema.Type)); this.Name = CommonConversion.ToCamelCase(propertySchema.Name); }
ProcessEvents(IReadOnlyList <string> serializedEvents) { lock (process) { var responses = serializedEvents.Select(serializedEvent => process.ProcessEvent(serializedEvent)) .ToImmutableList(); var compositionRecord = new CompositionRecordInFile { ParentHashBase16 = CommonConversion.StringBase16FromByteArray(lastStateHash), AppendedEvents = serializedEvents.Select(@event => new ValueInFile { LiteralString = @event }).ToImmutableList(), }; var serializedCompositionRecord = Encoding.UTF8.GetBytes(Serialize(compositionRecord)); var compositionHash = CompositionRecordInFile.HashFromSerialRepresentation(serializedCompositionRecord); lastStateHash = compositionHash; return(responses, (serializedCompositionRecord, compositionHash)); } }
/// <summary> /// Creates a property that gets the collection of relationship between tables in the data model. /// </summary> /// <param name="dataModelSchema">The data model schema.</param> public RelationsProperty(DataModelSchema dataModelSchema) { // /// <summary> // /// Gets the collection of relations that link tables and allow navigation between parent tables and child tables. // /// </summary> // [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] // [global::System.ComponentModel.BrowsableAttribute(false)] // public static global::System.Data.DataRelationCollection Relations { // get { // return FluidTrade.UnitTest.Server.DataModel.dataSet.Relations; // } // } this.Comments.Add(new CodeCommentStatement("<summary>", true)); this.Comments.Add(new CodeCommentStatement("Gets the collection of relations that link tables and allow navigation between parent tables and child tables.", true)); this.Comments.Add(new CodeCommentStatement("</summary>", true)); // HACK - Put this line back in for official releases //this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(System.Diagnostics.DebuggerNonUserCodeAttribute)))); this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(System.ComponentModel.BrowsableAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(false)))); this.Attributes = MemberAttributes.Public | MemberAttributes.Static; this.Type = new CodeGlobalTypeReference(typeof(System.Data.DataRelationCollection)); this.Name = "Relations"; this.GetStatements.Add( new CodeMethodReturnStatement( new CodePropertyReferenceExpression( new CodePropertyReferenceExpression( new CodeTypeReferenceExpression(dataModelSchema.Name), String.Format("{0}DataSet", CommonConversion.ToCamelCase(dataModelSchema.Name))), "Relations"))); }
/// <summary> /// Creates a method to handle moving the deleted records from the active data model to the deleted data model. /// </summary> /// <param name="schema">The data model schema.</param> public AddTransactionMethod(DataModelSchema dataModelSchema) { // /// <summary> // /// Adds a transaction item to the log. // /// </summary> // /// <param name="iRow">The record to be added to the transaction log.</param> // /// <param name="data">An array of updated fields.</param> // [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] // [global::System.ComponentModel.BrowsableAttribute(false)] // internal static void AddTransaction(IRow iRow, object[] data) // { this.Comments.Add(new CodeCommentStatement("<summary>", true)); this.Comments.Add(new CodeCommentStatement("Adds a transaction item to the log.", true)); this.Comments.Add(new CodeCommentStatement("</summary>", true)); this.Comments.Add(new CodeCommentStatement("<param name=\"iRow\">The record to be added to the transaction log.</param>", true)); this.Comments.Add(new CodeCommentStatement("<param name=\"data\">An array of updated fields.</param>", true)); this.CustomAttributes.AddRange(new CodeCustomAttributesForProperties()); this.Name = "AddTransaction"; this.Attributes = MemberAttributes.Assembly | MemberAttributes.Static; this.Parameters.Add(new CodeParameterDeclarationExpression(new CodeGlobalTypeReference(typeof(FluidTrade.Core.IRow)), "iRow")); this.Parameters.Add(new CodeParameterDeclarationExpression(new CodeGlobalTypeReference(typeof(Object[])), "data")); // DataModel.dataModelDataSet.AddTransaction(iRow, data); this.Statements.Add( new CodeMethodInvokeExpression( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(dataModelSchema.Name), String.Format("{0}DataSet", CommonConversion.ToCamelCase(dataModelSchema.Name))), "AddTransaction", new CodeArgumentReferenceExpression("iRow"), new CodeArgumentReferenceExpression("data"))); // } }
/// <summary> /// Creates a method to read an XML file. /// </summary> /// <param name="schema">The data model schema.</param> public ReadXmlMethod(DataModelSchema dataModelSchema) { // /// <summary> // /// Reads an XML file into the data model. // /// </summary> // /// <param name="fileName">The name of the file to read.</param> // public static void ReadXml(string fileName) // { this.Comments.Add(new CodeCommentStatement("<summary>", true)); this.Comments.Add(new CodeCommentStatement("Reads an XML file into the data model.", true)); this.Comments.Add(new CodeCommentStatement("</summary>", true)); this.Comments.Add(new CodeCommentStatement("<param name=\"fileName\">The name of the file to read.</param>", true)); this.Name = "ReadXml"; this.Attributes = MemberAttributes.Public | MemberAttributes.Static; this.Parameters.Add(new CodeParameterDeclarationExpression(new CodeGlobalTypeReference(typeof(String)), "fileName")); // DataModel.dataSet.ReadXml(fileName); this.Statements.Add( new CodeMethodInvokeExpression( new CodePropertyReferenceExpression( new CodeTypeReferenceExpression(dataModelSchema.Name), String.Format("{0}DataSet", CommonConversion.ToCamelCase(dataModelSchema.Name))), "ReadXml", new CodeArgumentReferenceExpression("fileName"))); // } }
/// <summary> /// An internal scalar field. /// </summary> public SchemaScalarField(PropertySchema propertySchema) { // internal FluidTrade.Sandbox.WorkingOrder.AskPrice askPrice; this.Attributes = MemberAttributes.Assembly; this.Type = new CodeTypeReference(propertySchema.Type); this.Name = CommonConversion.ToCamelCase(propertySchema.Name); }
/// <summary> /// Generates a property that gets the lock for the data model. /// </summary> public DataLockProperty(DataModelSchema dataModelSchema) { // /// <summary> // /// Gets the lock for the data model. // /// </summary> // public global::System.Threading.ReaderWriterLockSlim DataLock // { this.Comments.Add(new CodeCommentStatement("<summary>", true)); this.Comments.Add(new CodeCommentStatement("Gets the lock for the data model.", true)); this.Comments.Add(new CodeCommentStatement("</summary>", true)); this.CustomAttributes.AddRange(new CodeCustomAttributesForProperties()); this.Attributes = MemberAttributes.Public | MemberAttributes.Static; this.Type = new CodeGlobalTypeReference(typeof(ReaderWriterLockSlim)); this.Name = "DataLock"; // get // { // return this.dataLock; // } this.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(dataModelSchema.Name), String.Format("{0}DataSet", CommonConversion.ToCamelCase(dataModelSchema.Name))), "DataLock"))); // } }
/// <summary> /// Creates a property to return a collection of the tables in the data model. /// </summary> /// <param name="dataModelSchema">The data model schema.</param> public TablesProperty(DataModelSchema dataModelSchema) { // /// <summary> // /// Gets the collection of tables contained in the DataModel. // /// </summary> // [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] // [global::System.ComponentModel.BrowsableAttribute(false)] // [global::System.ComponentModel.DesignerSerializationVisibility(global::System.ComponentModel.DesignerSerializationVisibility.Content)] // public static global::System.Data.DataTableCollection Tables { // get { // return FluidTrade.UnitTest.Server.DataModel.dataSet.Tables; // } // } this.Comments.Add(new CodeCommentStatement("<summary>", true)); this.Comments.Add(new CodeCommentStatement(string.Format("Gets the collection of tables contained in the {0}.", dataModelSchema.Name), true)); this.Comments.Add(new CodeCommentStatement("</summary>", true)); this.CustomAttributes.AddRange(new CodeCustomAttributesForProperties()); this.Attributes = MemberAttributes.Public | MemberAttributes.Static; this.Type = new CodeGlobalTypeReference(typeof(System.Data.DataTableCollection)); this.Name = "Tables"; this.GetStatements.Add( new CodeMethodReturnStatement( new CodePropertyReferenceExpression( new CodePropertyReferenceExpression( new CodeTypeReferenceExpression(dataModelSchema.Name), String.Format("{0}DataSet", CommonConversion.ToCamelCase(dataModelSchema.Name))), "Tables"))); }
/// <summary> /// Represents an expression that creates an object array using an array of ColumnSchemas. /// </summary> /// <param name="columns">The columns used to create the array expression.</param> public CodeKeyCreateExpression(ColumnSchema[] columns) { this.CreateType = new CodeGlobalTypeReference(typeof(Object)); foreach (ColumnSchema columnSchema in columns) { this.Initializers.Add(new CodeArgumentReferenceExpression(CommonConversion.ToCamelCase(columnSchema.Name))); } }
/// <summary> /// Creates a private field to hold the generic DataSet. /// </summary> public DataSetField(DataModelSchema dataModelSchema) { // // The generic data behind the strongly typed data model. // private static global::System.Data.DataSet dataSet; this.Attributes = MemberAttributes.Assembly | MemberAttributes.Static; this.Type = new CodeTypeReference(string.Format("{0}DataSet", dataModelSchema.Name)); this.Name = string.Format("{0}DataSet", CommonConversion.ToCamelCase(dataModelSchema.Name)); }
public FrayteResult CreateWarehouseLocation(string LocationName, string countryCode) { FrayteResult result = new FrayteResult(); Location location = new Location(); location.WarehouseId = 1; location.LocationName = LocationName; location.CountryId = 228; dbContext.Locations.Add(location); dbContext.SaveChanges(); location.Barcode = CommonConversion.GetNewFrayteNumber() + "|" + countryCode + "|" + location.LocationId; dbContext.SaveChanges(); BarcodeSettings settings = new BarcodeSettings(); string data = location.Barcode; string type = "Code128"; short fontSize = 8; string font = "SimSun"; settings.Data2D = data; settings.Data = data; settings.Type = (BarCodeType)Enum.Parse(typeof(BarCodeType), type); if (fontSize != 0 && fontSize.ToString().Length > 0 && Int16.TryParse(fontSize.ToString(), out fontSize)) { if (font != null && font.Length > 0) { settings.TextFont = new System.Drawing.Font(font, fontSize, FontStyle.Bold); } } short barHeight = 15; if (barHeight != 0 && barHeight.ToString().Length > 0 && Int16.TryParse(barHeight.ToString(), out barHeight)) { settings.BarHeight = barHeight; } BarCodeGenerator generator = new BarCodeGenerator(settings); Image barcode = generator.GenerateImage(); // Path where we will have barcode string filePathToSave = AppSettings.LabelFolder + "Waerehouse/"; filePathToSave = HttpContext.Current.Server.MapPath(filePathToSave + location.LocationId); if (!System.IO.Directory.Exists(filePathToSave)) { System.IO.Directory.CreateDirectory(filePathToSave); } barcode.Save(filePathToSave + "/" + location.LocationName + ".Png"); result.Status = true; return(result); }
/// <summary> /// Creates an object that translates the parameters used for external methods to parameters for internal methods. /// </summary> public UpdateParameterMatrix(TableSchema tableSchema) { // Initialize the object. this.ExternalParameterItems = new SortedList <string, ExternalParameterItem>(); // Every set of update parameters requires a unique key to identify the record that is to be updated. UniqueConstraintParameterItem primaryKeyParameterItem = new UniqueConstraintParameterItem(); primaryKeyParameterItem.ActualDataType = typeof(Object[]); primaryKeyParameterItem.DeclaredDataType = typeof(Object[]); primaryKeyParameterItem.Description = String.Format("The required key for the {0} table.", tableSchema.Name); primaryKeyParameterItem.FieldDirection = FieldDirection.In; primaryKeyParameterItem.Name = String.Format("{0}Key", CommonConversion.ToCamelCase(tableSchema.Name)); this.ExternalParameterItems.Add(primaryKeyParameterItem.Name, primaryKeyParameterItem); // This will create an interface for the 'Update' method. foreach (KeyValuePair <string, ColumnSchema> columnPair in tableSchema.Columns) { // This column is turned into a simple parameter. ColumnSchema columnSchema = columnPair.Value; // If a column requires special processing, it is not handled with the rest of the parameters. bool isOrdinaryColumn = true; // The row version is required for the optimistic concurrency checking that is part of all update operations. if (columnSchema.IsRowVersion) { isOrdinaryColumn = false; SimpleParameterItem simpleParameterItem = new SimpleParameterItem(); simpleParameterItem.ActualDataType = columnSchema.DataType; simpleParameterItem.ColumnSchema = columnSchema; simpleParameterItem.DeclaredDataType = columnSchema.DataType; simpleParameterItem.Description = String.Format("The required value for the {0} column.", CommonConversion.ToCamelCase(columnSchema.Name)); simpleParameterItem.FieldDirection = FieldDirection.In; simpleParameterItem.Name = CommonConversion.ToCamelCase(columnSchema.Name); this.ExternalParameterItems.Add(simpleParameterItem.Name, simpleParameterItem); } // Ordinary parameters are passed from the external caller to the internal methods without modification or // interpretation. if (isOrdinaryColumn) { SimpleParameterItem simpleParameterItem = new SimpleParameterItem(); simpleParameterItem.ActualDataType = columnSchema.DataType; simpleParameterItem.ColumnSchema = columnSchema; simpleParameterItem.DeclaredDataType = typeof(Object); simpleParameterItem.Description = String.Format("The optional value for the {0} column.", CommonConversion.ToCamelCase(columnSchema.Name)); simpleParameterItem.FieldDirection = FieldDirection.In; simpleParameterItem.Name = CommonConversion.ToCamelCase(columnSchema.Name); this.ExternalParameterItems.Add(simpleParameterItem.Name, simpleParameterItem); } } }
static public void BuildConfiguration(string[] args) { string argumentValueFromParameterName(string parameterName) => args .Select(arg => Regex.Match(arg, parameterName + "=(.*)", RegexOptions.IgnoreCase)) .FirstOrDefault(match => match.Success) ?.Groups[1].Value; var outputArgument = argumentValueFromParameterName("--output"); var loweredElmOutputArgument = argumentValueFromParameterName("--lowered-elm-output"); var frontendWebElmMakeCommandAppendix = argumentValueFromParameterName("--frontend-web-elm-make-appendix"); var(configZipArchive, loweredElmAppFiles) = BuildConfigurationZipArchive(frontendWebElmMakeCommandAppendix); if (0 < loweredElmOutputArgument?.Length) { Console.WriteLine("I write the lowered Elm app to '" + loweredElmOutputArgument + "'."); foreach (var file in loweredElmAppFiles) { var outputPath = Path.Combine(new[] { loweredElmOutputArgument }.Concat(file.Key).ToArray()); Directory.CreateDirectory(Path.GetDirectoryName(outputPath)); File.WriteAllBytes(outputPath, file.Value.ToArray()); } } var configZipArchiveFileId = CommonConversion.StringBase16FromByteArray(CommonConversion.HashSHA256(configZipArchive)); var webAppConfigFileId = Composition.GetHash(Composition.FromTree(Composition.TreeFromSetOfBlobsWithCommonOSPath( ZipArchive.EntriesFromZipArchive(configZipArchive), System.Text.Encoding.UTF8))); Console.WriteLine( "I built zip archive " + configZipArchiveFileId + " containing web app config " + webAppConfigFileId + "."); if (outputArgument == null) { Console.WriteLine("I did not see a path for output, so I don't attempt to save the configuration to a file."); } else { Directory.CreateDirectory(Path.GetDirectoryName(outputArgument)); File.WriteAllBytes(outputArgument, configZipArchive); Console.WriteLine("I saved zip arcchive " + configZipArchiveFileId + " to '" + outputArgument + "'"); } }
/// <summary> /// Creates a field for the strongly typed row. /// </summary> public RowField(TableSchema tableSchema) { // // /// <summary> // /// The Department row that has been changed. // /// </summary> // private DepartmentRow departmentRow; this.Comments.Add(new CodeCommentStatement("<summary>", true)); this.Comments.Add(new CodeCommentStatement(String.Format("The {0} row that has been changed.", tableSchema.Name), true)); this.Comments.Add(new CodeCommentStatement("</summary>", true)); this.Attributes = MemberAttributes.Private; this.Type = new CodeTypeReference(String.Format("{0}Row", tableSchema.Name)); this.Name = String.Format("{0}Row", CommonConversion.ToCamelCase(tableSchema.Name)); }
/// <summary> /// Creates an object that translates the parameters used for external methods to parameters for internal methods. /// </summary> public CreateParameterMatrix(TableSchema tableSchema) { // Initialize the object. this.ExternalParameterItems = new SortedList <string, ExternalParameterItem>(); // This will create an interface for the 'Create' method. foreach (KeyValuePair <string, ColumnSchema> columnPair in tableSchema.Columns) { // This column is turned into a simple parameter. ColumnSchema columnSchema = columnPair.Value; // If a column requires special processing, it is not handled with the rest of the parameters. bool isOrdinaryColumn = true; // The row version is not used in the set of Create parameters. if (columnSchema.IsRowVersion) { isOrdinaryColumn = false; } // AutoIncremented columns can only be specified as output parameters. if (columnSchema.IsAutoIncrement) { isOrdinaryColumn = false; SimpleParameterItem simpleParameterItem = new SimpleParameterItem(); simpleParameterItem.ActualDataType = columnSchema.DataType; simpleParameterItem.ColumnSchema = columnSchema; simpleParameterItem.DeclaredDataType = columnSchema.DataType; simpleParameterItem.Description = String.Format("The generated value for the {0} column.", columnSchema.Name); simpleParameterItem.FieldDirection = FieldDirection.Out; simpleParameterItem.Name = CommonConversion.ToCamelCase(columnSchema.Name); this.ExternalParameterItems.Add(simpleParameterItem.Name, simpleParameterItem); } // The only complication for ordinary parameters is whether the data type can accept a default or not. if (isOrdinaryColumn) { SimpleParameterItem simpleParameterItem = new SimpleParameterItem(); bool isOptional = columnSchema.IsNullable || columnSchema.DefaultValue != DBNull.Value; simpleParameterItem.ActualDataType = columnSchema.DataType; simpleParameterItem.ColumnSchema = columnSchema; simpleParameterItem.DeclaredDataType = isOptional ? typeof(Object) : columnSchema.DataType; simpleParameterItem.Description = String.Format("The {0} value for the {1} column.", isOptional ? "optional" : "required", columnSchema.Name); simpleParameterItem.FieldDirection = FieldDirection.In; simpleParameterItem.Name = CommonConversion.ToCamelCase(columnSchema.Name); this.ExternalParameterItems.Add(simpleParameterItem.Name, simpleParameterItem); } } }
/// <summary> /// Creates an array of values from a unique constraint that can be used for finding records. /// </summary> /// <param name="uniqueConstraintSchema">A description of a unique constraint.</param> /// <returns>An array of expressions that can be used as a key for finding records in a table.</returns> public CodeExpression[] CreateKey(UniqueConstraintSchema uniqueConstraintSchema) { // This will cycle through all the foreign and simple parameters looking for any columns that match up to the child // columns of the constraint. When found, they are placed in the array in the proper order to match up against the // given unique constraint. List <CodeExpression> keys = new List <CodeExpression>(); foreach (ColumnSchema uniqueColumn in uniqueConstraintSchema.Columns) { foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in this.ExternalParameterItems) { // This correlates the unique constraint columns with the variables that have been created in the method to // hold the key values from the foreign tables. These variables exist outside of the conditional logic that // finds the parent row, so if the parent key is null, these values will also be null. However, since they're // still declared, they can be used to construct keys, which is useful when they're optional values. if (parameterPair.Value is ForeignKeyConstraintParameterItem) { ForeignKeyConstraintParameterItem foreignKeyConstraintParameterItem = parameterPair.Value as ForeignKeyConstraintParameterItem; ForeignKeyConstraintSchema foreignKeyConstraintSchema = foreignKeyConstraintParameterItem.ForeignKeyConstraintSchema; for (int columnIndex = 0; columnIndex < foreignKeyConstraintSchema.Columns.Length; columnIndex++) { if (uniqueColumn == foreignKeyConstraintSchema.Columns[columnIndex]) { foreach (ForeignKeyVariableItem foreignKeyVariableItem in foreignKeyConstraintParameterItem.ForeignKeyVariables) { if (foreignKeyConstraintSchema.Columns[columnIndex] == foreignKeyVariableItem.ColumnSchema) { keys.Add(foreignKeyVariableItem.Expression); } } } } } // This will match the columns described in the simple parameters to the columns in the unique constraint. if (parameterPair.Value is SimpleParameterItem) { SimpleParameterItem simpleParameterItem = parameterPair.Value as SimpleParameterItem; if (uniqueColumn == simpleParameterItem.ColumnSchema) { keys.Add(new CodeVariableReferenceExpression(CommonConversion.ToCamelCase(simpleParameterItem.ColumnSchema.Name))); } } } } // This array can be used as a key to find the record in a table. return(keys.ToArray()); }
public JsonResult GetProjec() { var eList = new List <ProjectMaster>(); try { eList = _commonService.GetProjectNameList().ToList(); } catch (Exception ex) { } var objstate = eList.Select(x => new { value = x.ProjectName + "-" + CommonConversion.AddOrdinal(x.OrderNuber) + " Order", Id = x.ProjectMasterId, display = x.DisplaySize, ram = x.Ram, rom = x.Rom }).ToList(); return(Json(objstate.ToArray(), JsonRequestBehavior.AllowGet)); }
//for project Name Auto Complete public JsonResult GetProjectNameList(string term) { List <ProjectMaster> eList; try { eList = _commonService.GetProjectNameList().Where(x => x.ProjectName.ToLower().Contains(term.ToLower())).OrderBy(x => x.ProjectName).ThenByDescending(x => x.OrderNuber).ToList(); } catch (Exception ex) { return(Json(ex)); } var objstate = eList.Select(x => new { value = x.ProjectName + "-" + CommonConversion.AddOrdinal(x.OrderNuber) + " Order", Id = x.ProjectMasterId, display = x.DisplaySize, ram = x.Ram, rom = x.Rom }).ToList(); return(Json(objstate.ToArray(), JsonRequestBehavior.AllowGet)); }