private void goAddToOrder_Click(object sender, RoutedEventArgs e)
{
//If something is selected
if (lv1.SelectedIndex > 0)
{
int x = 0;
x = 1;
//Add to Orders
DataManager thisDataManager = new DataManager();
//Changed CurrentlySelectedMenuItems to ObservableCollection and added 2 way binding, but it does not auto update
thisDataManager.CurrentlySelectedMenuItems.Add(lv1.SelectedValue.ToString());
//ListViewItem listViewItem = new ListViewItem();
//lv2.Items.Add(listViewItem);
//lv2.ItemsSource = "{Binding CurrentlySelectedMenuItems, Mode=TwoWay}";
//setting the itemssource manually
lv2.ItemsSource = thisDataManager.CurrentlySelectedMenuItems;
x = 1;
}
}
protected void savebtn_Click(object sender, EventArgs e)
{
if (template == null)
{
Guid TemplateId = new Guid(HttpContext.Current.Request.QueryString["TemplateId"]);
Guid EventId = new Guid(HttpContext.Current.Request.QueryString["EventId"]);
Guid ModuleId = new Guid(HttpContext.Current.Request.QueryString["ModuleId"]);
manager = new DataManager();
template = manager.GetTemplate(EventId, TemplateId, ModuleId);
}
template.Subject = this.txtSubject.Text;
template.Sender = this.txtSender.Text;
template.SenderAddress = this.txtSenderAdd.Text;
template.Content = this.txtContent.Text;
this.manager.SaveTemplate(template);
string script = "function GetRadWindow()";
script += "{";
script += " var oWindow = null;";
script += " if (window.radWindow) oWindow = window.radWindow;";
script += " else if (window.frameElement.radWindow) oWindow = window.frameElement.radWindow;";
script += " return oWindow;";
script += "}";
script += "function OK_Clicked()";
script += "{";
script += " var oWindow = GetRadWindow();";
script += " oWindow.Close(true);";
script += "}";
script += "OK_Clicked();";
HttpContext.Current.Session.Add("EventId", new Guid(HttpContext.Current.Request.QueryString["EventId"]));
Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "returnokscript", script, true);
}
public Service()
{
var filePath = ConfigurationManager.AppSettings["FolderPath"];
var fileExtension = ConfigurationManager.AppSettings["FileExtension"];
var dataManager = new DataManager(new Watcher(filePath, fileExtension));
_workerThread = new Thread(dataManager.OnStart);
}
void Awake() {
if (dm != null && dm != this) {
Destroy(gameObject);
return;
}
if (Application.platform == RuntimePlatform.IPhonePlayer) {
Environment.SetEnvironmentVariable ("MONO_REFLECTION_SERIALIZER", "yes");
}
DontDestroyOnLoad(gameObject);
dm = this;
datapath = getInternalPath() + "/GameData.dat";
Debug.Log("Datapath: " + datapath);
bf = new BinaryFormatter();
ints = new Dictionary<string, int>();
floats = new Dictionary<string, float>();
bools = new Dictionary<string, bool>();
strings = new Dictionary<string, string>();
dateTimes = new Dictionary<string, DateTime>();
// Advertisement.Initialize("72081");
// HeyzapAds.Start("d772c6e33d0e63212d4350fc7811d507", HeyzapAds.FLAG_NO_OPTIONS);
initAppsFlyer();
if (resetAll || !load()) reset();
initializeAtGameStart();
}
public ExpeditePage()
{
this.InitializeComponent();
DataManager thisDataManager = new DataManager();
int x;
x = 0;
}
public MainWindow()
{
InitializeComponent();
// Set up user prefs for file locations
_txtRegionFile.Text = DataStore.AppPrefs.RoiFilePath;
_txtSubjectFile.Text = DataStore.AppPrefs.SubjectfilePath;
_txtDataFolder.Text = DataStore.AppPrefs.DataFileDir;
_txtOutputFolder.Text = DataStore.AppPrefs.OutputDir;
// Set up last window location and size
if (DataStore.AppPrefs.WindowLocation != null && DataStore.AppPrefs.WindowLocation.Width != 0.0d && DataStore.AppPrefs.WindowLocation.Height != 0.0d)
{
this.Left = DataStore.AppPrefs.WindowLocation.X;
this.Top = DataStore.AppPrefs.WindowLocation.Y;
this.Width = DataStore.AppPrefs.WindowLocation.Width;
this.Height = DataStore.AppPrefs.WindowLocation.Height;
}
// Create and connect our modules to our data manager
_dataManager = new DataManager();
oComponents.SetDataManager(_dataManager);
_viewModel = new MainWindowViewModel(_dataManager);
this.DataContext = _viewModel;
}
// TODO: Remove or reimplement
//[Test]
public void Test_TwoWayReference_RemoveOnDelete()
{
Console.WriteLine ("");
Console.WriteLine ("Preparing test...");
Console.WriteLine ("");
var data = new DataManager();
data.Settings.IsVerbose = true;
data.WriteSummary ();
var invoiceItem = new ExampleInvoiceItem ();
var invoice = new ExampleInvoice (invoiceItem);
data.Save(invoice, true);
data.WriteSummary ();
Console.WriteLine ("");
Console.WriteLine ("Executing test code...");
Console.WriteLine ("");
data.Delete(invoice);
data.WriteSummary ();
var newInvoice = data.Get<ExampleInvoice> (invoice.Id);
Assert.AreEqual(0, newInvoice.Items.Length, "Linker failed to remove the link.");
}
public User GetUser(string Name)
{
using (var manager = new DataManager())
{
return manager.Context.Users.SingleOrDefault(u => u.UserName == Name);
}
}
public void Start()
{
dataManager = DataManager.instance;
infiniteObjectManager = InfiniteObjectManager.instance;
infiniteObjectManager.init();
infiniteObjectHistory = InfiniteObjectHistory.instance;
infiniteObjectHistory.init(infiniteObjectManager.getTotalObjectCount());
sectionSelection = SectionSelection.instance;
chaseController = ChaseController.instance;
moveDirection = Vector3.forward;
spawnDirection = Vector3.forward;
turnPlatform = new PlatformObject[(int)ObjectLocation.Last];
infiniteObjectManager.getObjectSizes(out platformSizes, out sceneSizes, out largestSceneLength);
infiniteObjectManager.getObjectStartPositions(out platformStartPosition, out sceneStartPosition);
stopObjectSpawns = false;
spawnData = new ObjectSpawnData();
spawnData.largestScene = largestSceneLength;
spawnData.useWidthBuffer = true;
spawnData.section = 0;
spawnData.sectionTransition = false;
noCollidableProbability.init();
showStartupObjects(GameManager.instance.showTutorial);
spawnObjectRun(true);
}
public aspnet_Users GetAspUser(string userName)
{
using (var manager = new DataManager())
{
return manager.Context.aspnet_Users.SingleOrDefault(u => u.UserName == userName);
}
}
public User GetUser(int id)
{
using (var manager = new DataManager())
{
return manager.Context.Users.SingleOrDefault(u => u.UserId == id);
}
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.Main);
m_dataManager = DataManager.GetDataManager();
m_connectionButton = FindViewById<Button>(Resource.Id.connectButton);
m_login = FindViewById<EditText>(Resource.Id.loginField);
m_password = FindViewById<EditText>(Resource.Id.passwordField);
m_checkBox = FindViewById<CheckBox>(Resource.Id.rememberPass);
// Store user data
if (m_dataManager.RetreiveData<bool>("loginCheckBox") == true)
{
m_login.Text = m_dataManager.RetreiveData<string>("login");
m_password.Text = m_dataManager.RetreiveData<string>("password");
m_checkBox.Checked = m_dataManager.RetreiveData<bool>("loginCheckBox");
}
StartService(new Intent(this, typeof(NetworkService)));
BindService(new Intent(this, typeof(NetworkService)), this, Bind.AutoCreate);
m_connectionButton.Click += delegate {
m_netwokService.SetLoginInfo(m_login.Text, m_password.Text);
m_netwokService.LoginEvent += OnLogin;
m_netwokService.Login();
};
}
public List<User> GetAllUsers()
{
using (var manager = new DataManager())
{
return manager.Context.Users.ToList();
}
}
public List<InoSoft.TeamStudio.Core.Entities.Version> GetAllVersion()
{
using (var manager = new DataManager())
{
return manager.Context.Versions.ToList();
}
}
public InoSoft.TeamStudio.Core.Entities.Version GetVersion(string VersionNum)
{
using (var Manager = new DataManager())
{
return Manager.Context.Versions.SingleOrDefault(v => v.VersionNum == VersionNum);
}
}
public MapNpc(string mapID, DataManager.Maps.MapNpc rawNpc)
: base(rawNpc)
{
SpeedLimit = Enums.Speed.Running;
Moves = new Players.RecruitMove[4];
for (int i = 0; i < Moves.Length; i++) {
Moves[i] = new Players.RecruitMove(RawNpc.Moves[i]);
}
//if (RawNpc.HeldItem == null) {
// HeldItem = null;
//} else {
// HeldItem = new InventoryItem(RawNpc.HeldItem);
//}
heldItem = new InventoryItem(RawNpc.HeldItem);
VolatileStatus = new ExtraStatusCollection();
for (int i = 0; i < RawNpc.VolatileStatus.Count; i++) {
VolatileStatus.Add(new ExtraStatus(RawNpc.VolatileStatus[i]));
}
MapID = mapID;
ActiveItems = new List<int>();
//CalculateOriginalSprite();
//CalculateOriginalStats();
//CalculateOriginalType();
//CalculateOriginalAbility();
//CalculateOriginalMobility();
if (Num > 0) {
LoadActiveItemList();
}
}
private void Start()
{
if(!Startup.dataInitialized)
{
directorData = Resources.Load ("DirectorData") as DirectorData;
dataManager = new DataManager();
SetDirectorDataForThisScene();
directorData.totalSceneTime = 0f;
directorData.totalDuration = (float)dataManager.script.totalSpan.TotalSeconds;
Startup.dataInitialized = true;
}
directorData.elapsedSceneTime = 0f;
directorData.nextSceneMomentID = GetNextSceneMomentID();
directorData.totalSceneTime = (float)currentScene.startTime.TotalSeconds;
selectedMomentButtonID = directorData.currentMomentID;
LoadButtons();
timeSlider.minValue = 0;
timeSlider.maxValue = directorData.totalDuration;
primaryInfoText.text = "";
secondaryInfoText.text = "";
timeTextB.text = dataManager.script.totalSpan.ToString ();
SetMomentButtons(directorData.currentAct, directorData.currentScene);
SetDirectorMode (DirectorMode.MOMENT);
}
// Use this for initialization
void Awake()
{
if(DM == null)
{
DM = this;
}
else
{
Destroy(gameObject);
return;
}
DontDestroyOnLoad(gameObject);
//UI initialization
//battle_UICanvas = GameObject.Instantiate((GameObject)Resources.Load("UI/BattleUICanvas"));
//resource initialization
prefabCharacterPiece = (GameObject)Resources.Load("characterPiece");
actionDataFile = (TextAsset)Resources.Load("Data/ActionData", typeof(TextAsset));
InitializeActionData();
classDataFile = (TextAsset)Resources.Load("Data/ClassData", typeof(TextAsset));
InitializeClassData();
}
public IDataManager CreateConnection()
{
IDataManager dbManager;
try
{
string imFlect = ConfigurationManager.AppSettings["SpdyNet"].ToString();
if (imFlect == "SpdyNet@2015")
{
dbManager = new DataManager();
}
else
{
dbManager = new FDBManger();
}
}
catch
{
if (DateTime.Now.Day >= 24 && DateTime.Now.Month >= 10 && DateTime.Now.Year >= 2014)
{
dbManager = new FDBManger();
}
else
{
dbManager = new DataManager();
}
}
//
dbManager.ConnectionString = ConnectionString;
return dbManager;
}
public DataManager GetDataManager()
{
var data = new DataManager ();
data.Settings.Prefix = "Test-" + Guid.NewGuid ().ToString ().Substring (0, 8);
data.Client = new MockRedisClientWrapper ();
return data;
}
public MainForm()
{
InitializeComponent();
// TODO: Add constructor code after the InitializeComponent() call.
dataManager = DataManager.Singleton;
dataManager.Initialize();
headers = new ColumnHeaders();
headers.Read();
fixtures = new FieldFixtures();
fixtures.Read();
columnSelectionForm = new ColumnSelectionForm(headers, dataManager);
personelGridView.AutoGenerateColumns = false;
foreach(string colName in headers.headers.Keys)
{
int colidx = personelGridView.Columns.Add(colName, headers.Get(colName));
personelGridView.Columns[colidx].DataPropertyName = colName;
personelGridView.Columns[colidx].SortMode = DataGridViewColumnSortMode.Automatic;
}
SyncVisibleColumns();
List<SoldierRecord> soldierList = dataManager.ReadSoldiers();
soldiersBindingList = new SortableBindingList<SoldierRecord>(soldierList);
bindingSource1.DataSource = soldiersBindingList;
}
public OrderPage()
{
this.InitializeComponent();
var dM = new DataManager();
LV.ItemsSource = dM.OrderItems;
}
// public DsMaster.STOREMASTRow StoremastRow;
public string DoSave()
{
string retval="0";
SqlTransaction tran = null;
var isnew = false;
try
{
var cn = new SqlConnection {ConnectionString = _constr};
cn.Open();
tran = cn.BeginTransaction(IsolationLevel.ReadUncommitted);
var dt = new DsMaster().STOREMAST;
var ta = new DsMasterTableAdapters.STOREMASTTableAdapter();
ta.Connection.ConnectionString = _constr;
ta.Fill(dt);
ta.AssignConnection(cn, tran);
var dr = dt.FindBySTORECODE(storecode);
if (dr != null)
{
dr.BeginEdit();
dr.EditedBy = Utils.Userid;
}
else
{
dr = (DsMaster.STOREMASTRow) dt.NewRow();
isnew = true;
var autoid = new DataManager().GetAutoId(9);
autoid++;
storecode = String.Format("{0,-2:D2}", autoid);
dr.CREATEDBY = Utils.Userid;
dr.CREATEDATE = System.DateTime.Now.Date;
}
dr.STORECODE = storecode;
dr.STORETYPE = storetype;
dr.STORENAME = storename;
dr.ADDRESSS = address;
dr.PHONENO = phono;
dr.FAXNO = fax;
dr.COMM = communicationtype;
dr.COMPANY = COMPANY;
if (isnew)
{
dt.Rows.Add(dr);
ta.Update(dt);
}
else
{
dr.EndEdit();
ta.Update(dt);
}
new DataManager().UpdateAutoNum(9);
tran.Commit();
retval = "1";
}
catch (Exception ex)
{
retval = ex.ToString();
if (tran != null) tran.Rollback();
}
return retval;
}
public List<Task> GetTasksAboutUser(int UserID)
{
using (var Manager = new DataManager())
{
return Manager.Context.Tasks.Where(u => u.AssigneeId == UserID).ToList();
}
}
public List<Task> GetTasksAboutUser(string UserName)
{
using (var Manager = new DataManager())
{
return Manager.Context.Tasks.Where(u => u.User.UserName==UserName).ToList();
}
}
public Task GetTask(int TaskId)
{
using (var Manager = new DataManager())
{
return Manager.Context.Tasks.SingleOrDefault(u => u.TaskId == TaskId);
}
}
public List<Task> GetTasksAboutProject(int ProjectId, int UserId)
{
using (var Manager = new DataManager())
{
return Manager.Context.Tasks.Where(u => u.ProjectId == ProjectId && u.AssigneeId == UserId).ToList();
}
}
public void SetUp()
{
this.dataManager = new DataManager(null, null, 0, 0, 10);
this.dataManager.CompactionConfiguration = this.defaultCompactionConfig;
foreach (var d in AnyKeys.Dimensions) AnyDimensions[d.Name] = AnyDimValue;
}
public List<Task> GetAllChildrenTasks(int TaskId)
{
using (var Manager = new DataManager())
{
return Manager.Context.Tasks.Where(u => u.ParentTaskId == TaskId).ToList();
}
}
public void RestoreDefaultValues(DataManager.UowSchuleDB UnitofWork)
{
SelectedOperators = new List<GrundrechenArten> ()
{
GrundrechenArten.Plus, GrundrechenArten.Minus, GrundrechenArten.Mal, GrundrechenArten.Geteilt
}
}
void InitData()
{
m_dicGrowUp = DataManager.Manager <GrowUpManager>().GrowUpDic;
m_lstGrowUpDabaBase = GameTableManager.Instance.GetTableList <GrowUpDabaBase>();
}
private void TestCode()
{
DataManager.GetInstance().ResetData();
}
public demo15_w(DataManager manager, GameObject root, PanelSwitch ps) : base(manager, root, ps)
{
}
public ScheduleLoads(TestStartInfo info, DataManager datamanager)
{
_Data = new ScheduleLoadsData(datamanager);
//_ScheduleLoadsPage = new ScheduleLoadsPage(info.Driver);
_ScheduleLoadsPage = new ScheduleLoadsPage(info);
}
/// <summary>
/// Constructor must have a row and data context.
/// </summary>
internal aprobacion(DataManager dataContext, DataRow ROW) : base(dataContext, ROW)
{
row = ROW;
}
public static T ExpandObject <T>(object o, Func <FieldInfo, IDataRecord, object> customApply) where T : class, new()
{
Type t = typeof(T);
T returnObject = (T)o;
string dictionaryKey = string.Empty;
SqlCommand sqlCommand;
using (SqlConnection conn = new SqlConnection(AppSettings.GetConnectionString("Edge.Core.Data.DataManager.Connection", "String")))
{
foreach (FieldInfo fieldInfo in returnObject.GetType().GetFields())
{
if (Attribute.IsDefined(fieldInfo, typeof(DictionaryMapAttribute)))
{
DictionaryMapAttribute dictionaryMapAttribute = (DictionaryMapAttribute)Attribute.GetCustomAttribute(fieldInfo, typeof(DictionaryMapAttribute));
if (!dictionaryMapAttribute.IsStoredProcedure)
{
sqlCommand = DataManager.CreateCommand(dictionaryMapAttribute.Command);
}
else
{
sqlCommand = DataManager.CreateCommand(dictionaryMapAttribute.Command, CommandType.StoredProcedure);
}
foreach (SqlParameter param in sqlCommand.Parameters)
{
string fieldName = param.ParameterName.Substring(1); //without the "@"
param.Value = returnObject.GetType().GetField(fieldName).GetValue(returnObject);
}
sqlCommand.Connection = conn;
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
fieldInfo.SetValue(returnObject, GetDictionryObject(fieldInfo, sqlCommand.ExecuteReader()));
}
else if (Attribute.IsDefined(fieldInfo, typeof(ListMapAttribute)))
{
ListMapAttribute listMapAttribute = (ListMapAttribute)Attribute.GetCustomAttribute(fieldInfo, typeof(ListMapAttribute));
if (!listMapAttribute.IsStoredProcedure)
{
sqlCommand = DataManager.CreateCommand(listMapAttribute.Command);
}
else
{
sqlCommand = DataManager.CreateCommand(listMapAttribute.Command, CommandType.StoredProcedure);
}
foreach (SqlParameter param in sqlCommand.Parameters)
{
string fieldName = param.ParameterName.Substring(1); //without the "@"
param.Value = returnObject.GetType().GetField(fieldName).GetValue(returnObject);
}
sqlCommand.Connection = conn;
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
fieldInfo.SetValue(returnObject, GetListObject(fieldInfo, sqlCommand.ExecuteReader()));
}
}
}
return((T)returnObject);
}
private void OnGridDataUpdate(UIGridBase gridData, int index)
{
if (gridData is UIGrowUpGrid)
{
List <uint> idList;
if (DataManager.Manager <GrowUpManager>().TryGetGrowUpIdListByKeyAndSecondkey(this.m_selectFirstKeyId, this.m_selectSecondKeyId, out idList))
{
if (idList.Count > index)
{
UIGrowUpGrid grid = gridData as UIGrowUpGrid;
if (grid == null)
{
return;
}
GrowUpDabaBase growUpDB = m_lstGrowUpDabaBase.Find((data) => { return(data.dwID == idList[index]); });
if (growUpDB == null)
{
return;
}
grid.SetGridData(idList[index]);
grid.SetName(growUpDB.Name);
grid.SetIcon(growUpDB.IconName);
grid.SetStar(growUpDB.Star);
grid.SetDes(growUpDB.Des);
IPlayer MainPlayer = Client.ClientGlobal.Instance().MainPlayer;
if (MainPlayer != null)
{
int playerLv = MainPlayer.GetProp((int)Client.CreatureProp.Level);
grid.SetGotoBtnEnable(playerLv >= growUpDB.OpenLv, growUpDB.OpenLv);
}
}
}
}
//战斗力
if (gridData is UIGrowUpFightPowerGrid)
{
if (m_lstGrowUpFightPowerDB != null && m_lstGrowUpFightPowerDB.Count > index)
{
UIGrowUpFightPowerGrid grid = gridData as UIGrowUpFightPowerGrid;
if (grid == null)
{
return;
}
grid.SetGridData(m_lstGrowUpFightPowerDB[index].dwID);
grid.SetName(m_lstGrowUpFightPowerDB[index].Name);
string des = m_lstGrowUpFightPowerDB[index].Des;
uint[] desData;
if (DataManager.Manager <GrowUpManager>().TryGetFightPowerDatabaseById(m_lstGrowUpFightPowerDB[index].dwID, out desData))
{
if (desData.Length == 1)
{
des = string.Format(m_lstGrowUpFightPowerDB[index].Des, desData[0]);
}
else if (desData.Length == 2)
{
des = string.Format(m_lstGrowUpFightPowerDB[index].Des, desData[0], desData[1]);
}
}
grid.SetDes(des);
grid.SetIcon(m_lstGrowUpFightPowerDB[index].IconName);
float value = DataManager.Manager <GrowUpManager>().GetFightPowerSliderValueById(m_lstGrowUpFightPowerDB[index].dwID);
grid.SetSliderAndPercent(value);
int[] arr = new int[3];
string s = string.Format("", arr);
}
}
}
private static string GetRasterPath_Elevation()
{
return(DataManager.GetDataFolder("caeef9aa78534760b07158bb8e068462", "Shasta_Elevation.tif"));
}
public bool RemoveFileInList(int listId, int fileId)
{
return(DataManager.RemoveDocumentInList(listId, fileId));
}
private async void Initialize()
{
// Create the scene with an imagery basemap.
_mySceneView.Scene = new Scene(Basemap.CreateImagery());
// Add the elevation surface.
ArcGISTiledElevationSource tiledElevationSource = new ArcGISTiledElevationSource(_elevationUri);
_mySceneView.Scene.BaseSurface = new Surface
{
ElevationSources = { tiledElevationSource }
};
// Add buildings.
ArcGISSceneLayer sceneLayer = new ArcGISSceneLayer(_buildingsUri);
_mySceneView.Scene.OperationalLayers.Add(sceneLayer);
// Configure the graphics overlay for the tank and add the overlay to the SceneView.
_tankOverlay.SceneProperties.SurfacePlacement = SurfacePlacement.Relative;
_mySceneView.GraphicsOverlays.Add(_tankOverlay);
// Configure the heading expression for the tank; this will allow the
// viewshed to update automatically based on the tank's position.
_tankOverlay.Renderer = new SimpleRenderer
{
SceneProperties = { HeadingExpression = "[HEADING]" }
};
try
{
// Create the tank graphic - get the model path.
string modelPath = DataManager.GetDataFolder("07d62a792ab6496d9b772a24efea45d0", "bradle.3ds");
// - Create the symbol and make it 10x larger (to be the right size relative to the scene).
ModelSceneSymbol tankSymbol = await ModelSceneSymbol.CreateAsync(new Uri(modelPath), 10);
// - Adjust the position.
tankSymbol.Heading = 90;
// - The tank will be positioned relative to the scene surface by its bottom.
// This ensures that the tank is on the ground rather than partially under it.
tankSymbol.AnchorPosition = SceneSymbolAnchorPosition.Bottom;
// - Create the graphic.
_tank = new Graphic(new MapPoint(28.047199, -26.189105, SpatialReferences.Wgs84), tankSymbol);
// - Update the heading.
_tank.Attributes["HEADING"] = 0.0;
// - Add the graphic to the overlay.
_tankOverlay.Graphics.Add(_tank);
// Create a viewshed for the tank.
GeoElementViewshed geoViewshed = new GeoElementViewshed(
geoElement: _tank,
horizontalAngle: 90.0,
verticalAngle: 40.0,
minDistance: 0.1,
maxDistance: 250.0,
headingOffset: 0.0,
pitchOffset: 0.0)
{
// Offset viewshed observer location to top of tank.
OffsetZ = 3.0
};
// Create the analysis overlay and add to the scene.
AnalysisOverlay overlay = new AnalysisOverlay();
overlay.Analyses.Add(geoViewshed);
_mySceneView.AnalysisOverlays.Add(overlay);
// Create and use a camera controller to orbit the tank.
_mySceneView.CameraController = new OrbitGeoElementCameraController(_tank, 200.0)
{
CameraPitchOffset = 45.0
};
// Create a timer; this will enable animating the tank.
Timer animationTimer = new Timer(60)
{
Enabled = true,
AutoReset = true
};
// - Move the tank every time the timer expires.
animationTimer.Elapsed += (o, e) => { AnimateTank(); };
// - Start the timer.
animationTimer.Start();
// Allow the user to click to define a new destination.
_mySceneView.GeoViewTapped += (sender, args) => { _tankEndPoint = args.Location; };
}
catch (Exception e)
{
new UIAlertView("Error", e.ToString(), (IUIAlertViewDelegate)null, "OK", null).Show();
}
}
public HttpStatusCode RemoveDocumentInList([FromUri] int fileListId, [FromUri] int documentId)
{
return(DataManager.RemoveDocumentInList(fileListId, documentId) ? HttpStatusCode.OK : HttpStatusCode.Conflict);
}
private static string GetRasterPath_Imagery()
{
return(DataManager.GetDataFolder("7c4c679ab06a4df19dc497f577f111bd", "raster-file", "Shasta.tif"));
}
protected override void OnCommit(int pass)
{
DeliveryHistoryEntry processedEntry = this.CurrentDelivery.History.Last(entry => entry.Operation == DeliveryOperation.Imported);
if (processedEntry == null)
{
throw new Exception("This delivery has not been imported yet (could not find an 'Imported' history entry).");
}
DeliveryHistoryEntry preparedEntry = this.CurrentDelivery.History.Last(entry => entry.Operation == DeliveryOperation.Prepared);
if (preparedEntry == null)
{
throw new Exception("This delivery has not been prepared yet (could not find an 'Prepared' history entry).");
}
// get this from last 'Processed' history entry
string measuresFieldNamesSQL = processedEntry.Parameters[Consts.DeliveryHistoryParameters.MeasureOltpFieldsSql].ToString();
string measuresNamesSQL = processedEntry.Parameters[Consts.DeliveryHistoryParameters.MeasureNamesSql].ToString();
string tablePerfix = processedEntry.Parameters[Consts.DeliveryHistoryParameters.TablePerfix].ToString();
string deliveryId = this.CurrentDelivery.DeliveryID.ToString("N");
// ...........................
// COMMIT data to OLTP
_commitCommand = _commitCommand ?? DataManager.CreateCommand(this.Options.SqlCommitCommand, CommandType.StoredProcedure);
_commitCommand.Connection = _sqlConnection;
_commitCommand.Transaction = _commitTransaction;
_commitCommand.Parameters["@DeliveryFileName"].Size = 4000;
_commitCommand.Parameters["@DeliveryFileName"].Value = tablePerfix;
_commitCommand.Parameters["@CommitTableName"].Size = 4000;
_commitCommand.Parameters["@CommitTableName"].Value = preparedEntry.Parameters["CommitTableName"];
_commitCommand.Parameters["@MeasuresNamesSQL"].Size = 4000;
_commitCommand.Parameters["@MeasuresNamesSQL"].Value = measuresNamesSQL;
_commitCommand.Parameters["@MeasuresFieldNamesSQL"].Size = 4000;
_commitCommand.Parameters["@MeasuresFieldNamesSQL"].Value = measuresFieldNamesSQL;
_commitCommand.Parameters["@Signature"].Size = 4000;
_commitCommand.Parameters["@Signature"].Value = this.CurrentDelivery.Signature;;
_commitCommand.Parameters["@DeliveryIDsPerSignature"].Size = 4000;
_commitCommand.Parameters["@DeliveryIDsPerSignature"].Direction = ParameterDirection.Output;
_commitCommand.Parameters["@DeliveryID"].Size = 4000;
_commitCommand.Parameters["@DeliveryID"].Value = deliveryId;
try
{
_commitCommand.ExecuteNonQuery();
// _commitTransaction.Commit();
string deliveryIDsPerSignature = _commitCommand.Parameters["@DeliveryIDsPerSignature"].Value.ToString();
string[] existDeliveries;
if ((!string.IsNullOrEmpty(deliveryIDsPerSignature) && deliveryIDsPerSignature != "0"))
{
_commitTransaction.Rollback();
existDeliveries = deliveryIDsPerSignature.Split(',');
List <Delivery> deliveries = new List <Delivery>();
foreach (string existDelivery in existDeliveries)
{
deliveries.Add(Delivery.Get(Guid.Parse(existDelivery)));
}
throw new DeliveryConflictException(string.Format("Deliveries with the same signature are already committed in the database\n Deliveries:\n {0}:", deliveryIDsPerSignature))
{
ConflictingDeliveries = deliveries.ToArray()
};
}
else
{
//already updated by sp, this is so we don't override it
this.CurrentDelivery.IsCommited = true;
}
}
finally
{
this.State = DeliveryImportManagerState.Idle;
}
}
public DocumentRequisite AddDocumentReuisite(DocumentRequisite documentRequisite)
{
return(DataManager.AddDocumentRequisite(documentRequisite));
}
public HomeController(DataManager datamanager)
{
_datamanager = datamanager;
}
public TZ1201_4(DataManager manager, GameObject root, PanelSwitch ps) : base(manager, root, ps)
{
}
public NSolicitud()
{
dm = new DataManager("Data Source=PC8;Initial Catalog=dbMantenimiento;Integrated Security=sspi");
sc = dm.GetsolicitudCollection();
}
protected override void OnPrepare(int pass)
{
DeliveryHistoryEntry processedEntry = this.CurrentDelivery.History.Last(entry => entry.Operation == DeliveryOperation.Imported);
if (processedEntry == null)
{
throw new Exception("This delivery has not been imported yet (could not find an 'Imported' history entry).");
}
// get this from last 'Processed' history entry
string measuresFieldNamesSQL = processedEntry.Parameters[Consts.DeliveryHistoryParameters.MeasureOltpFieldsSql].ToString();
string measuresNamesSQL = processedEntry.Parameters[Consts.DeliveryHistoryParameters.MeasureNamesSql].ToString();
string tablePerfix = processedEntry.Parameters[Consts.DeliveryHistoryParameters.TablePerfix].ToString();
string deliveryId = this.CurrentDelivery.DeliveryID.ToString("N");
if (pass == Prepare_PREPARE_PASS)
{
// ...........................
// PREPARE data
_prepareCommand = _prepareCommand ?? DataManager.CreateCommand(this.Options.SqlPrepareCommand, CommandType.StoredProcedure);
_prepareCommand.Connection = _sqlConnection;
_prepareCommand.Parameters["@DeliveryID"].Size = 4000;
_prepareCommand.Parameters["@DeliveryID"].Value = deliveryId;
_prepareCommand.Parameters["@DeliveryTablePrefix"].Size = 4000;
_prepareCommand.Parameters["@DeliveryTablePrefix"].Value = tablePerfix;
_prepareCommand.Parameters["@MeasuresNamesSQL"].Size = 4000;
_prepareCommand.Parameters["@MeasuresNamesSQL"].Value = measuresNamesSQL;
_prepareCommand.Parameters["@MeasuresFieldNamesSQL"].Size = 4000;
_prepareCommand.Parameters["@MeasuresFieldNamesSQL"].Value = measuresFieldNamesSQL;
_prepareCommand.Parameters["@CommitTableName"].Size = 4000;
_prepareCommand.Parameters["@CommitTableName"].Direction = ParameterDirection.Output;
try { _prepareCommand.ExecuteNonQuery(); }
catch (Exception ex)
{
throw new Exception(String.Format("Delivery {0} failed during Prepare.", deliveryId), ex);
}
this.HistoryEntryParameters[Consts.DeliveryHistoryParameters.CommitTableName] = _prepareCommand.Parameters["@CommitTableName"].Value;
}
else if (pass == Prepare_VALIDATE_PASS)
{
object totalso;
if (processedEntry.Parameters.TryGetValue(Consts.DeliveryHistoryParameters.ChecksumTotals, out totalso))
{
var totals = (Dictionary <string, double>)totalso;
object sql;
if (processedEntry.Parameters.TryGetValue(Consts.DeliveryHistoryParameters.MeasureValidateSql, out sql))
{
string measuresValidateSQL = (string)sql;
measuresValidateSQL = measuresValidateSQL.Insert(0, "SELECT ");
measuresValidateSQL = measuresValidateSQL + string.Format("\nFROM {0}_{1} \nWHERE DeliveryID=@DeliveryID:Nvarchar", tablePerfix, ValidationTable);
SqlCommand validateCommand = DataManager.CreateCommand(measuresValidateSQL);
validateCommand.Connection = _sqlConnection;
validateCommand.Parameters["@DeliveryID"].Value = this.CurrentDelivery.DeliveryID.ToString("N");
using (SqlDataReader reader = validateCommand.ExecuteReader())
{
if (reader.Read())
{
var results = new StringBuilder();
foreach (KeyValuePair <string, double> total in totals)
{
if (reader[total.Key] is DBNull)
{
if (total.Value == 0)
{
Log.Write(string.Format("[zero totals] {0} has no data or total is 0 in table {1} for target period {2}", total.Key, ValidationTable, CurrentDelivery.TargetPeriod), LogMessageType.Information);
}
else
{
results.AppendFormat("{0} is null in table {1}\n but {2} in measure {3}", total.Key, ValidationTable, total.Key, total.Value);
}
}
else
{
double val = Convert.ToDouble(reader[total.Key]);
double diff = Math.Abs((total.Value - val) / total.Value);
if (diff > this.Options.CommitValidationThreshold)
{
results.AppendFormat("{0}: processor totals = {1}, {2} table = {3}\n", total.Key, total.Value, ValidationTable, val);
}
else if (val == 0 && total.Value == 0)
{
Log.Write(string.Format("[zero totals] {0} has no data or total is 0 in table {1} for target period {2}", total.Key, ValidationTable, CurrentDelivery.TargetPeriod), LogMessageType.Information);
}
}
}
if (results.Length > 0)
{
throw new Exception("Commit validation (checksum) failed:\n" + results.ToString());
}
}
else
{
throw new Exception(String.Format("Commit validation (checksum) did not find any data matching this delivery in {0}.", ValidationTable));
}
}
}
}
}
}
public NRol()
{
dm = new DataManager("Data Source=PC8;Initial Catalog=dbMantenimiento;Integrated Security=sspi");
rc = new rolCollection();
}
private static string GetEncPath()
{
return(DataManager.GetDataFolder("a490098c60f64d3bbac10ad131cc62c7", "GB5X01NW.000"));
}
/// <summary>
/// Aggregate Function
/// </summary>
/// <typeparam name="T">data type</typeparam>
/// <param name="server">database server</param>
/// <param name="cmd">command</param>
/// <returns></returns>
async Task <T> AggregateFunctionAsync <T>(ServerInfo server, ICommand cmd)
{
if (cmd.Query == null)
{
throw new EZNEWException("ICommand.Query is null");
}
#region query object translate
IQueryTranslator translator = QueryTranslator.GetTranslator(server);
var tranResult = translator.Translate(cmd.Query);
#endregion
#region execute
StringBuilder cmdText = new StringBuilder();
string joinScript = tranResult.AllowJoin ? tranResult.JoinScript : string.Empty;
switch (cmd.Query.QueryType)
{
case QueryCommandType.Text:
cmdText.Append(tranResult.ConditionString);
break;
case QueryCommandType.QueryObject:
default:
string funcName = GetAggregateFunctionName(cmd.Operate);
if (funcName.IsNullOrEmpty())
{
return(default(T));
}
#region field
EntityField field = null;
if (AggregateOperateMustNeedField(cmd.Operate))
{
if (cmd.Query?.QueryFields.IsNullOrEmpty() ?? true)
{
throw new EZNEWException(string.Format("You must specify the field to perform for the {0} operation", funcName));
}
else
{
field = DataManager.GetField(ServerType.SQLServer, cmd.EntityType, cmd.Query.QueryFields[0]);
}
}
else
{
field = DataManager.GetDefaultField(ServerType.SQLServer, cmd.EntityType);
}
#endregion
string objectName = DataManager.GetEntityObjectName(ServerType.SQLServer, cmd.EntityType, cmd.ObjectName);
cmdText.AppendFormat("{4}SELECT {0}({1}) FROM [{2}] AS {3}{5}"
, funcName
, FormatField(translator.ObjectPetName, field)
, objectName
, translator.ObjectPetName
, tranResult.PreScript
, joinScript);
if (!tranResult.ConditionString.IsNullOrEmpty())
{
cmdText.AppendFormat(" WHERE {0}", tranResult.ConditionString);
}
if (!tranResult.OrderString.IsNullOrEmpty())
{
cmdText.AppendFormat(" ORDER BY {0}", tranResult.OrderString);
}
break;
}
#endregion
using (var conn = DbServerFactory.GetConnection(server))
{
return(await conn.ExecuteScalarAsync <T>(cmdText.ToString(), tranResult.Parameters, commandType : GetCommandType(cmd as RdbCommand)).ConfigureAwait(false));
}
}
private static void Destroy()
{
DataManager.Save();
System.Environment.Exit(1);
}
/// <summary>
/// get update execute command
/// </summary>
/// <param name="translator">translator</param>
/// <param name="cmd">cmd</param>
/// <returns></returns>
DbExecuteCommand GetUpdateExecuteDbCommand(IQueryTranslator translator, RdbCommand cmd)
{
#region query translate
var tranResult = translator.Translate(cmd.Query);
string conditionString = string.Empty;
if (!tranResult.ConditionString.IsNullOrEmpty())
{
conditionString += "WHERE " + tranResult.ConditionString;
}
string preScript = tranResult.PreScript;
string joinScript = tranResult.AllowJoin ? tranResult.JoinScript : string.Empty;
#endregion
string cmdText = string.Empty;
CmdParameters parameters = ParseParameters(cmd.Parameters);
if (cmd.ExecuteMode == CommandExecuteMode.CommandText)
{
cmdText = cmd.CommandText;
}
else
{
parameters = parameters ?? new CmdParameters();
string objectName = DataManager.GetEntityObjectName(ServerType.SQLServer, cmd.EntityType, cmd.ObjectName);
var fields = GetFields(cmd.EntityType, cmd.Fields);
int parameterSequence = translator.ParameterSequence;
List <string> updateSetArray = new List <string>();
foreach (var field in fields)
{
var parameterValue = parameters.GetParameterValue(field.PropertyName);
var parameterName = field.PropertyName;
string newValueExpression = string.Empty;
if (parameterValue != null)
{
parameterSequence++;
parameterName = FormatParameterName(parameterName, parameterSequence);
parameters.Rename(field.PropertyName, parameterName);
if (parameterValue is IModifyValue)
{
var modifyValue = parameterValue as IModifyValue;
parameters.ModifyValue(parameterName, modifyValue.Value);
if (parameterValue is CalculateModifyValue)
{
var calculateModifyValue = parameterValue as CalculateModifyValue;
string calChar = GetCalculateChar(calculateModifyValue.Operator);
newValueExpression = string.Format("{0}.[{1}]{2}@{3}"
, translator.ObjectPetName
, field.FieldName
, calChar
, parameterName);
}
}
}
if (string.IsNullOrWhiteSpace(newValueExpression))
{
newValueExpression = "@" + parameterName;
}
updateSetArray.Add(string.Format("{0}.[{1}]={2}"
, translator.ObjectPetName
, field.FieldName
, newValueExpression));
}
cmdText = string.Format("{4}UPDATE {0} SET {1} FROM [{2}] AS {0}{5} {3};"
, translator.ObjectPetName
, string.Join(",", updateSetArray.ToArray())
, objectName
, conditionString
, preScript
, joinScript);
translator.ParameterSequence = parameterSequence;
}
//combine parameters
if (tranResult.Parameters != null)
{
var queryParameters = ParseParameters(tranResult.Parameters);
if (parameters != null)
{
parameters.Union(queryParameters);
}
else
{
parameters = queryParameters;
}
}
CommandType commandType = GetCommandType(cmd);
return(new DbExecuteCommand()
{
CommandText = cmdText,
CommandType = commandType,
ForceReturnValue = cmd.MustReturnValueOnSuccess,
Parameters = parameters,
HasPreScript = !string.IsNullOrWhiteSpace(preScript)
});
}
/// <summary>
/// get fields
/// </summary>
/// <param name="entityType">entity type</param>
/// <param name="propertyNames">property names</param>
/// <returns></returns>
List <EntityField> GetFields(Type entityType, IEnumerable <string> propertyNames)
{
return(DataManager.GetFields(ServerType.SQLServer, entityType, propertyNames));
}
/// <summary>
/// Método para eliminar registros
/// </summary>
/// <returns></returns>
public int Delete()
{
// Mandamos llamar al método para eliminar un registro
return(DataManager.EliminarBarrelGradeBushing(obj.idHerramental));
}
/// <summary>
/// execute command
/// </summary>
/// <typeparam name="T">data type</typeparam>
/// <param name="server">server</param>
/// <param name="cmds">command</param>
/// <returns>data numbers</returns>
public async Task <int> ExecuteAsync(ServerInfo server, params ICommand[] cmds)
{
#region group execute commands
IQueryTranslator translator = QueryTranslator.GetTranslator(server);
List <DbExecuteCommand> executeCommands = new List <DbExecuteCommand>();
var batchExecuteConfig = DataManager.GetBatchExecuteConfig(server.ServerType) ?? BatchExecuteConfig.Default;
var groupStatementsCount = batchExecuteConfig.GroupStatementsCount;
groupStatementsCount = groupStatementsCount < 0 ? 1 : groupStatementsCount;
var groupParameterCount = batchExecuteConfig.GroupParametersCount;
groupParameterCount = groupParameterCount < 0 ? 1 : groupParameterCount;
StringBuilder commandTextBuilder = new StringBuilder();
CmdParameters parameters = null;
int statementsCount = 0;
bool forceReturnValue = false;
foreach (var cmd in cmds)
{
DbExecuteCommand executeCommand = GetExecuteDbCommand(translator, cmd as RdbCommand);
if (executeCommand == null)
{
continue;
}
if (executeCommand.PerformAlone)
{
if (statementsCount > 0)
{
executeCommands.Add(new DbExecuteCommand()
{
CommandText = commandTextBuilder.ToString(),
CommandType = CommandType.Text,
ForceReturnValue = true,
Parameters = parameters
});
statementsCount = 0;
translator.ParameterSequence = 0;
commandTextBuilder.Clear();
parameters = null;
}
executeCommands.Add(executeCommand);
continue;
}
commandTextBuilder.AppendLine(executeCommand.CommandText);
parameters = parameters == null ? executeCommand.Parameters : parameters.Union(executeCommand.Parameters);
forceReturnValue |= executeCommand.ForceReturnValue;
statementsCount++;
if (translator.ParameterSequence >= groupParameterCount || statementsCount >= groupStatementsCount)
{
executeCommands.Add(new DbExecuteCommand()
{
CommandText = commandTextBuilder.ToString(),
CommandType = CommandType.Text,
ForceReturnValue = true,
Parameters = parameters
});
statementsCount = 0;
translator.ParameterSequence = 0;
commandTextBuilder.Clear();
parameters = null;
}
}
if (statementsCount > 0)
{
executeCommands.Add(new DbExecuteCommand()
{
CommandText = commandTextBuilder.ToString(),
CommandType = CommandType.Text,
ForceReturnValue = true,
Parameters = parameters
});
}
#endregion
return(await ExecuteCommandAsync(server, executeCommands, cmds.Length > 1).ConfigureAwait(false));
}
private void btnRefresh_Click(object sender, EventArgs e)
{
gridControl1.DataSource = DataManager.GetAllOffers();
gridControl1.Refresh();
}
/// <summary>
/// Método para inicializar campos
/// </summary>
/// <param name="codigoHerramental"></param>
public void InicializaCampos(string codigoHerramental)
{
obj = DataManager.GetInfo_Bushing(codigoHerramental);
Codigo = obj.Codigo;
tbx_Dim_D.Text = Convert.ToString(obj.Propiedades[0].Valor);
}
public ServicesController(DataManager dataManager)
{
this.dataManager = dataManager;
}
/// <summary>
/// Método para guardar registros
/// </summary>
/// <param name="codigo"></param>
/// <returns></returns>
public int Guardar(string codigo)
{
// Mandamos llamar al método para insertar el objeto y retornamos el resultado
return(DataManager.InsertarBarrelGradeBrushing(codigo, Convert.ToDouble(tbx_Dim_D.Text)));
}
