/*
* Params use native values now, this is unnecessary
* public static Alphora.Dataphor.DAE.Runtime.Data.DataValue DataValue(Schema.IDataType AType, object AValue, DAECommand ACommand)
* {
* if (AValue == null)
* return null;
* return Alphora.Dataphor.DAE.Runtime.Data.DataValue.FromNative(((DAEConnection)ACommand.Connection).ServerProcess, AType, AValue);
* }
*/
internal string Prepare(string commandText, DAECommand command)
{
if (commandText.IndexOf(ParameterName) > -1)
{
DataParam runtimeParam = null;
if (command.DAERuntimeParams.IndexOf(ParameterName) < 0)
{
if ((Direction == ParameterDirection.Output) || (Direction == ParameterDirection.ReturnValue))
{
runtimeParam = new DataParam(ParameterName, DataTypeFromDAEDbType(_type, (DAEConnection)command.Connection), Modifier(Direction));
}
else
{
runtimeParam = new DataParam(ParameterName, DataTypeFromDAEDbType(_type, (DAEConnection)command.Connection), Modifier(Direction), _value);
}
command.DAERuntimeParams.Add(runtimeParam);
}
else
{
runtimeParam = command.DAERuntimeParams[ParameterName];
if ((Direction != ParameterDirection.Output) && (Direction != ParameterDirection.ReturnValue))
{
runtimeParam.Value = _value;
}
}
}
return(commandText);
}
private void Param_OnChangeValue(DataParam dataParam)
{
this.Dispatcher.Invoke(new ThreadStart(delegate {
double angle = -135;
if ((MaxValue > 0) && (dataParams[0] != null))
{
double division = 270 / (MaxValue - MinValue);
if (Math.Abs(dataParams[0].Value) < MaxValue)
{
angle = -135 + (Math.Abs(dataParams[0].Value) - MinValue) * division;
}
else
{
angle = 0;
}
if (angle < -135)
{
angle = -135;
}
if (angle > 135)
{
angle = 135;
}
RotateTransform rotate = new RotateTransform(angle)
{
CenterX = 73, CenterY = 59
};
TranslateTransform toCenter = new TranslateTransform(73, 59);
TransformGroup transformGroup = new TransformGroup();
transformGroup.Children.Add(toCenter);
transformGroup.Children.Add(rotate);
arrow.RenderTransform = transformGroup;
}
}));
}
private void Param_OnChangeValue(DataParam dataParam)
{
this.Dispatcher.Invoke(new ThreadStart(delegate {
canvasColumn.Children.Clear();
Rectangle rect = new Rectangle();
rect.Width = canvasColumn.ActualWidth;
double resultHeight = (dataParams[0].Value - MinValue) * canvasColumn.ActualHeight / (MaxValue - MinValue);
rect.Height = (resultHeight >= 0) ? resultHeight : 0;
if (rect.Height > canvasColumn.ActualHeight)
{
rect.Height = canvasColumn.ActualHeight + 10;
}
rect.Fill = new SolidColorBrush(Colors.Blue);
this.lValue.Foreground = (Brush)((Setter)(((Style)FindResource("LabelStyle")).Setters[0])).Value;
if ((dataParams[0].AlarmMax != 0) || (dataParams[0].AlarmMin != 0))
{
if (dataParams[0].Value < dataParams[0].AlarmMin)
{
rect.Fill = new SolidColorBrush(Helper.MinColor);
this.lValue.Foreground = new SolidColorBrush(Helper.MinColor);
}
if (dataParams[0].Value > dataParams[0].AlarmMax)
{
rect.Fill = new SolidColorBrush(Helper.MaxColor);
this.lValue.Foreground = new SolidColorBrush(Helper.MaxColor);
}
}
canvasColumn.Children.Add(rect);
Canvas.SetTop(rect, canvasColumn.ActualHeight - rect.Height);
Canvas.SetLeft(rect, 0);
}));
}
public override object InternalExecute(Program program, object[] arguments)
{
StringWriter text = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(text);
writer.Formatting = Formatting.Indented;
// Find the root element
DataParams paramsValue = new DataParams();
paramsValue.Add(DataParam.Create(program.ServerProcess, "ADocumentID", (Guid)arguments[0]));
Guid rootElementID =
((IScalar)
((IServerProcess)program.ServerProcess).Evaluate
(
"Root_Element_ID from row from (XMLDocument where ID = ADocumentID)",
paramsValue
)
).AsGuid;
// Write the root element
WriteElement(program, writer, rootElementID);
writer.Flush();
return(text.ToString());
}
private void DataParam_OnChangeTitle(DataParam param)
{
for (int i = 0; i < DataParams.Count; i++)
{
Model.Series[i].Title = DataParams[i].Title;
}
plotter.InvalidatePlot(false);
}
/*******************************************/
private static DataParam PopulateParam(this DataParam parameter, IGH_Param component)
{
parameter.Name = component.NickName;
parameter.Description = component.Description;
parameter.BHoM_Guid = component.InstanceGuid;
parameter.TargetIds = component.Recipients.Select(r => r.InstanceGuid).ToList();
return(parameter);
}
public static DataParam Create <T>(string name, T value)
{
DataParam dataParam = new DataParam(name, value);
if (value == null)
{
dataParam.Type = typeof(T);
}
return(dataParam);
}
/// <summary>
///
/// </summary>
/// <param name="sqlQueryString"></param>
/// <param name="paramName"></param>
/// <param name="paramValue"></param>
public TermCondition(string sqlQueryString, string paramName, object paramValue)
{
if (paramValue != null)
{
if (DataParam == null)
{
DataParam = new ParameterCollection();
}
DataParam.Add(paramName, paramValue);
}
this.SqlQueryString = sqlQueryString;
}
private static void InsertDocument(IServerProcess process, Guid documentID, Guid rootElementID)
{
DataParams paramsValue = new DataParams();
paramsValue.Add(DataParam.Create(process, "ADocumentID", documentID));
paramsValue.Add(DataParam.Create(process, "AElementID", rootElementID));
process.Execute
(
"insert table { row { ADocumentID ID, AElementID Root_Element_ID }, key { } } into .System.Internet.XMLDocument",
paramsValue
);
}
public static void SetDataOutputParams(IServerProcess process, DataParams dataParams, NativeParam[] nativeParams)
{
for (int index = 0; index < dataParams.Count; index++)
{
DataParam dataParam = dataParams[index];
if ((dataParam.Modifier == Modifier.Var) || (dataParam.Modifier == Modifier.Out))
{
var dataValue = NativeValueToDataValue((ServerProcess)process, nativeParams[index].Value);
dataParam.Value = dataValue.IsNil ? null : dataValue.AsNative;
}
}
}
private void Param_OnChangeValue(DataParam dataParam)
{
this.Dispatcher.Invoke(new ThreadStart(delegate {
if (dataParams[0].Value == 0)
{
ellipse.Fill = new SolidColorBrush(Colors.Red);
}
else
{
ellipse.Fill = new SolidColorBrush(Colors.Green);
}
}));
}
/*******************************************/
private static ParamNode ParamNode(this DataParam parameter)
{
return(new ParamNode
{
Name = parameter.Name,
Description = parameter.Description,
BHoM_Guid = parameter.BHoM_Guid,
Inputs = new List <ReceiverParam>(),
Outputs = new List <DataParam> {
parameter
}
});
}
private static void WriteContent(IServerProcess process, Guid elementID, string content, int childSequence, byte type)
{
DataParams paramsValue = new DataParams();
paramsValue.Add(DataParam.Create(process, "AElementID", elementID));
paramsValue.Add(DataParam.Create(process, "ASequence", childSequence));
paramsValue.Add(DataParam.Create(process, "AContent", content));
paramsValue.Add(DataParam.Create(process, "AType", type));
process.Execute
(
"insert table { row { AElementID Element_ID, ASequence Sequence, AContent Content, AType Type }, key { } } into .System.Internet.XMLContent",
paramsValue
);
}
public IHttpActionResult PostNCFJSON([FromBody] DataParam param)
{
ResponseMsg response = null;
try
{
response = DbService.executeTransaction(param.TipoSecuencia, param.Sistema, param.NumeroFactura);
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
return(Ok(response));
}
private void Param_OnChangeValue(DataParam dataParam)
{
this.Dispatcher.Invoke(new ThreadStart(delegate {
foreach (LineSeries line in plotter.Model.Series)
{
if (line.Title == dataParam.Title)
{
if (line.Points.Count > CountDot)
{
line.Points.RemoveAt(0);
}
line.Points.Add(new DataPoint(DateTimeAxis.ToDouble(DateTime.Now), dataParam.Value));
plotter.InvalidatePlot(true);
}
}
}));
}
private void Param_OnChangeValue(DataParam dataParam)
{
this.Dispatcher.Invoke(new ThreadStart(delegate {
if ((dataParams[0].AlarmMax != 0) || (dataParams[0].AlarmMin != 0))
{
this.lValue.Foreground = (Brush)((Setter)(((Style)FindResource("LabelStyle")).Setters[0])).Value;
if (dataParams[0].Value < dataParams[0].AlarmMin)
{
this.lValue.Foreground = new SolidColorBrush(Helper.MinColor);
}
if (dataParams[0].Value > dataParams[0].AlarmMax)
{
this.lValue.Foreground = new SolidColorBrush(Helper.MaxColor);
}
}
}));
}
private void ColorChange_Click(object sender, RoutedEventArgs e)
{
if (dgParamSetting.SelectedItem == null)
{
return;
}
Button b = (Button)sender;
System.Windows.Forms.ColorDialog cd = new System.Windows.Forms.ColorDialog();
cd.Color = System.Drawing.Color.FromArgb(((Color)b.Background.GetValue(SolidColorBrush.ColorProperty)).R,
((Color)b.Background.GetValue(SolidColorBrush.ColorProperty)).G,
((Color)b.Background.GetValue(SolidColorBrush.ColorProperty)).B);
if (cd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
DataParam dataParam = (DataParam)dgParamSetting.SelectedItem;
dataParam.ColorLine = new SolidColorBrush(Color.FromRgb(cd.Color.R, cd.Color.G, cd.Color.B));
b.Background = dataParam.ColorLine;
}
}
public static string PostSource(string url, DataParam dataParams)
{
var date = ConverterUnixTime.ConvertToUnixTime(dataParams.Date);
var city = dataParams.CityId;
var cinema = dataParams.CinemaId;
var offset = dataParams.Offset;
var limit = dataParams.Limit;
var sort = dataParams.Sort;
string data = $"date={date}&city={city}&kinoteatr={cinema}&offset={offset}&limit={limit}&sort={sort}";
WebRequest request = ConnectRequest(url, "application/x-www-form-urlencoded", "POST");
using (var sWrite = new StreamWriter(request.GetRequestStream()))
{
sWrite.Write(data);
}
var source = WebResponseSource(request);
return(source);
}
public IHttpActionResult Post([FromBody] DataParam param)
{
//String result = String.Empty;
ResponseMsg response = null;
/*--
* try
* {
* NavisConnect service = new NavisConnect();
* result = service.executeGenericInvokeDPH_PERMISSON(param.UnitNbr, param.Action, param.Nota);
* }
* catch (Exception ex)
* {
* return InternalServerError(ex);
* }
*
* String[] arg = result.Split('|');
*
* if (arg.Length == 2)
* {
*
* //
* if (arg[0].Equals("OK"))
* {
* response = new ResponseMsg() { Status = "OK", Codigo = "0", Message = arg[1] };
* }
* else
* {
* response = new ResponseMsg() { Status = "OK", Codigo = "1", Message = arg[1] };
* }
*
* }
* --*/
response = new ResponseMsg()
{
Status = "OK", Codigo = "1", Message = "OK"
};
return(Ok(response));
}
public static DataParams NativeParamsToDataParams(ServerProcess process, NativeParam[] nativeParams)
{
DataParams dataParams = new DataParams();
if (nativeParams != null)
{
foreach (var nativeParam in nativeParams)
{
var value = NativeValueToDataValue(process, nativeParam.Value);
DataParam dataParam =
new DataParam
(
nativeParam.Name,
value.DataType,
NativeCLIUtility.NativeModifierToModifier(nativeParam.Modifier),
value.IsNil ? null : (value is IScalar ? value.AsNative : value)
);
dataParams.Add(dataParam);
}
}
return(dataParams);
}
//fill procedure with param and return
public static void FillPRocedureParamsFromSQLAgent(this DataSItem procedure, DbAgent agent = null)
{
string source;
if (agent != null)
{
source = agent.ConnectionString;
}
else
{
source = _currentagent.ConnectionString;
}
using (SqlConnection con = new SqlConnection(source))
{
con.Open();
using (SqlCommand cmd = new SqlCommand(string.Format(_getParamsOFProc, procedure.Name), con))
{
procedure.Params.Clear();
cmd.CommandType = CommandType.Text;
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
DataParam prm = new DataParam();
prm.Name = reader[0].ToString();
prm.Default = "";
prm.Direction = GetDirection(reader[1].ToString());
prm.Type = GetType(reader[2].ToString());
prm.SetParent(procedure);
procedure.AddParam(prm);
}
}
}
}
public void Analyze()
{
PrepareForExecute();
string plan;
var errors = new ErrorList();
try
{
using (var statusForm = new StatusForm(Strings.ProcessingQuery))
{
DateTime startTime = DateTime.Now;
try
{
var paramsValue = new DataParams();
paramsValue.Add(DataParam.Create(Dataphoria.UtilityProcess, "AQuery", GetTextToExecute()));
plan = ((DAE.Runtime.Data.Scalar)Dataphoria.EvaluateQuery("ShowPlan(AQuery)", paramsValue)).AsString;
}
finally
{
TimeSpan elapsed = DateTime.Now - startTime;
_executionTimeStatus.Text = elapsed.ToString();
}
}
}
catch (Exception exception)
{
errors.Add(exception);
ProcessErrors(errors);
SetStatus(Strings.ScriptAnalyzeFailed);
return;
}
SetStatus(Strings.ScriptAnalyzeSuccessful);
var analyzer = (Analyzer.Analyzer)Dataphoria.OpenDesigner(Dataphoria.GetDefaultDesigner("pla"), null);
analyzer.LoadPlan(plan);
}
private static void SetupCommand(IDbCommand cmd, string cmdText, CommandType cmdType, int?cmdTimeout, DataParam[] dbParams, IDbTransaction tran)
{
cmd.CommandText = cmdText;
cmd.CommandType = cmdType;
if (cmdTimeout.HasValue)
{
cmd.CommandTimeout = cmdTimeout.Value;
}
if (tran != null)
{
cmd.Transaction = tran;
}
if (dbParams != null)
{
for (int i = 0; i < dbParams.Length; i++)
{
DataParam dataParam = dbParams[i];
IDbDataParameter dbDataParameter = cmd.CreateParameter();
dbDataParameter.Value = dataParam.Value;
cmd.Parameters.Add(dbDataParameter);
}
}
}
/*******************************************/
public static INode ToNode(this GH_ValueList component, List <object> choices, object selectedItem)
{
int index = 0;
bool success = component.SelectedItems.First().Value.CastTo <int>(out index);
if (success && index >= 0 && index < choices.Count)
{
object choice = choices[index];
if (component.GetType().Name == "CreateDataComponent")
{
DataParam parameter = PopulateParam(new DataParam {
Data = choice as BHoMObject, DataType = choice.GetType()
}, component);
return(new LibraryNode
{
SourceFile = selectedItem as string,
Name = parameter.Name,
Description = parameter.Description,
BHoM_Guid = parameter.BHoM_Guid,
Inputs = new List <ReceiverParam>(),
Outputs = new List <DataParam> {
parameter
}
});
}
else
{
return(ParamNode(PopulateParam(new DataParam {
Data = choice, DataType = choice.GetType()
}, component)));
}
}
else
{
return(null);
}
}
private void Param_OnChangeValue(DataParam dataParam)
{
this.Dispatcher.Invoke(new ThreadStart(delegate {
foreach (LineSeries line in plotter.Model.Series)
{
if (line.Title == dataParam.Title)
{
if (Setting.DepthOnlineGraph > 0)
{
Model.Axes[0].Minimum = DateTimeAxis.ToDouble(DateTime.Now.AddSeconds(-1 * Setting.DepthOnlineGraph));
/*while (line.Points.Count > Setting.DepthOnlineGraph / Setting.intervalReadGS)
* line.Points.RemoveAt(0);*/
}
if (dataParam.LastValue.ValueString != "Н/Д")
{
line.Points.Add(new DataPoint(DateTimeAxis.ToDouble(DateTime.Now), dataParam.LastValue.Value));
}
plotter.InvalidatePlot(true);
}
}
Model.Axes[0].Maximum = OxyPlot.Axes.DateTimeAxis.ToDouble(DateTime.Now);
}));
}
private static Guid InsertElement(IServerProcess process, Guid documentID, XmlTextReader reader, Guid parentID, int sequence)
{
Guid elementID = Guid.NewGuid();
DataParams paramsValue = new DataParams();
// Insert the element
paramsValue.Add(DataParam.Create(process, "AElementID", elementID));
paramsValue.Add(DataParam.Create(process, "ADocumentID", documentID));
paramsValue.Add(DataParam.Create(process, "ANamespaceAlias", reader.Prefix));
paramsValue.Add(DataParam.Create(process, "AName", reader.LocalName));
process.Execute
(
"insert table { row { AElementID ID, ADocumentID Document_ID, ANamespaceAlias NamespaceAlias, "
+ "AName Name }, key { } } into .System.Internet.XMLElement",
paramsValue
);
// Attach to parent
if (parentID != Guid.Empty)
{
paramsValue.Clear();
paramsValue.Add(DataParam.Create(process, "AElementID", elementID));
paramsValue.Add(DataParam.Create(process, "AParentElementID", parentID));
paramsValue.Add(DataParam.Create(process, "ASequence", sequence));
process.Execute
(
"insert table { row { AElementID Element_ID, AParentElementID Parent_Element_ID, ASequence Sequence }, key { } } into .System.Internet.XMLElementParent",
paramsValue
);
}
// Add attributes
while (reader.MoveToNextAttribute())
{
paramsValue.Clear();
paramsValue.Add(DataParam.Create(process, "AElementID", elementID));
paramsValue.Add(DataParam.Create(process, "AValue", reader.Value));
if (String.Compare(reader.Name, "xmlns", true) == 0) // Default namespace
{
process.Execute
(
"insert table { row { AElementID Element_ID, AValue URI }, key { } } into .System.Internet.XMLDefaultNamespace",
paramsValue
);
}
else if (String.Compare(reader.Prefix, "xmlns", true) == 0) // Namespace alias
{
paramsValue.Add(DataParam.Create(process, "ANamespaceAlias", reader.LocalName));
process.Execute
(
"insert table { row { AElementID Element_ID, ANamespaceAlias NamespaceAlias, AValue URI }, key { } } into .System.Internet.XMLNamespaceAlias",
paramsValue
);
}
else // regular attribute
{
paramsValue.Add(DataParam.Create(process, "ANamespaceAlias", reader.Prefix));
paramsValue.Add(DataParam.Create(process, "AName", reader.LocalName));
process.Execute
(
"insert table { row { AElementID Element_ID, ANamespaceAlias NamespaceAlias, AName Name, AValue Value }, key { } } into .System.Internet.XMLAttribute",
paramsValue
);
}
}
reader.MoveToElement();
if (!reader.IsEmptyElement)
{
int childSequence = 0;
XmlNodeType nodeType;
// Add child elements
do
{
reader.Read();
nodeType = reader.NodeType;
switch (nodeType)
{
case XmlNodeType.Text: WriteContent(process, elementID, reader.Value, childSequence++, 0); break;
case XmlNodeType.CDATA: WriteContent(process, elementID, reader.Value, childSequence++, 1); break;
case XmlNodeType.Element: InsertElement(process, documentID, reader, elementID, childSequence++); break;
}
} while (nodeType != XmlNodeType.EndElement);
}
return(elementID);
}
public string GetSource(string url, DataParam data)
{
var source = Connecter.Connecter.PostSource(url, data);
return(source);
}
public void WinGame()
{
gemAdd = 0;
gameState = GameState.gameover;
WinSound();
PlayerController.instance.playerState = PlayerController.PlayerState.Win;
PlayerController.instance.AnimWin();
PlayerController.instance.rid.velocity = Vector2.zero;
PlayerController.instance.box.enabled = false;
PlayerController.instance.speedmove = 0;
MissionController.Instance.DoMission(0, timePlay);
MissionController.Instance.DoMission(3, (int)((PlayerController.instance.health / PlayerController.instance.maxHealth) * 100));
MissionController.Instance.DoMission(6, reviveCount);
if (countStar == 0)
{
countStar = 1;
}
if (MissionController.Instance.listMissions[0].isDone)
{
countStar++;
}
if (MissionController.Instance.listMissions[1].isDone)
{
countStar++;
}
if (countStar >= 1)
{
if (DataUtils.modeSelected == 0)
{
if (DataUtils.First1Star(DataUtils.modeSelected, DataParam.indexStage, DataParam.indexMap) == false)
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin1star);
Debug.LogError("star 1 normal lan dau");
}
else
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin1star / 100 * 10);
Debug.LogError("star 1 normal lan sau");
}
}
else
{
if (DataUtils.First1Star(DataUtils.modeSelected, DataParam.indexStage, DataParam.indexMap) == false)
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin1star * 1.5f);
Debug.LogError("star 1 hard lan dau");
}
else
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin1star * 1.5f / 100 * 10);
Debug.LogError("star 1 hard lan dau");
}
}
}
if (countStar >= 2)
{
if (DataUtils.modeSelected == 0)
{
if (DataUtils.First2Star(DataUtils.modeSelected, DataParam.indexStage, DataParam.indexMap) == false)
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin2star);
Debug.LogError("star 2 normal lan dau");
}
else
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin2star / 100 * 10);
Debug.LogError("star 2 normal lan sau");
}
}
else
{
if (DataUtils.First2Star(DataUtils.modeSelected, DataParam.indexStage, DataParam.indexMap) == false)
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin2star * 1.5f);
Debug.LogError("star 2 hard lan dau");
}
else
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin2star * 1.5f / 100 * 10);
Debug.LogError("star 2 hard lan dau");
}
}
}
if (countStar == 3)
{
if (DataUtils.modeSelected == 0)
{
if (DataUtils.First3Star(DataUtils.modeSelected, DataParam.indexStage, DataParam.indexMap) == false)
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin3star);
Debug.LogError("star 3 normal lan dau");
gemAdd = (int)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].bonusgem;
DataUtils.AddCoinAndGame(0, gemAdd);
}
else
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin3star / 100 * 10);
Debug.LogError("star 3 normal lan sau");
}
}
else
{
if (DataUtils.First3Star(DataUtils.modeSelected, DataParam.indexStage, DataParam.indexMap) == false)
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin3star * 1.5f);
Debug.LogError("star 3 hard lan dau");
gemAdd = Mathf.RoundToInt((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].bonusgem * 1.5f);
DataUtils.AddCoinAndGame(0, gemAdd);
}
else
{
DataParam.AddCoin((float)DataController.instance.allMission[DataParam.indexStage].missionData[DataParam.indexMap].coin3star * 1.5f / 100 * 10);
Debug.LogError("star 3 hard lan dau");
}
DataController.instance.DoDailyQuest(7, 1);
}
DataController.instance.DoDailyQuest(2, 1);
}
DataUtils.SaveLevel(DataParam.indexStage, DataParam.indexMap);
MissionController.Instance.CheckMission();
MyAnalytics.LogEventLevelComplete(DataParam.indexMap, DataParam.indexStage);
DataController.instance.DoAchievement(6, 1);
if (reviveCount == 0)
{
DataController.instance.DoAchievement(7, 1);
if (DataUtils.modeSelected == 1)
{
DataController.instance.DoDailyQuest(9, 1);
}
}
if (DataParam.indexMap == 7)
{
if (DataParam.indexStage == 0)
{
DataController.instance.DoAchievement(8, 1);
}
if (DataParam.indexStage == 1)
{
DataController.instance.DoAchievement(9, 1);
}
}
if (DataUtils.modeSelected == 1)
{
DataController.instance.DoDailyQuest(4, 1);
}
if (DataController.primeAccout.isVIP)
{
DataParam.AddCoin(DataParam.totalCoin / 100 * 20);
}
DataUtils.AddCoinAndGame((int)DataParam.totalCoin, 0);
ThemManh();
StartCoroutine(delayDisplayFinish());
}
private void WriteElement(Program program, XmlTextWriter writer, Guid elementID)
{
// Write the element header
DataParams paramsValue = new DataParams();
paramsValue.Add(DataParam.Create(program.ServerProcess, "AElementID", elementID));
using
(
IRow element =
(IRow)((IServerProcess)program.ServerProcess).Evaluate
(
"row from (XMLElement where ID = AElementID)",
paramsValue
)
)
{
string namespaceAlias = (string)element["NamespaceAlias"];
if (namespaceAlias != String.Empty)
{
namespaceAlias = namespaceAlias + ":";
}
writer.WriteStartElement(namespaceAlias + (string)element["Name"]);
}
// Write any default namespace changes
IScalar defaultValue =
(IScalar)((IServerProcess)program.ServerProcess).Evaluate
(
"URI from row from (XMLDefaultNamespace where Element_ID = AElementID)",
paramsValue
);
if (defaultValue != null)
{
writer.WriteAttributeString("xmlns", defaultValue.AsString);
}
// Write namespace aliases
IServerCursor aliases =
(IServerCursor)((IServerProcess)program.ServerProcess).OpenCursor
(
"XMLNamespaceAlias where Element_ID = AElementID",
paramsValue
);
try
{
while (aliases.Next())
{
using (IRow row = aliases.Select())
writer.WriteAttributeString("xmlns:" + (string)row["NamespaceAlias"], (string)row["URI"]);
}
}
finally
{
((IServerProcess)program.ServerProcess).CloseCursor(aliases);
}
// Write the attributes
IServerCursor attributes =
(IServerCursor)((IServerProcess)program.ServerProcess).OpenCursor
(
"XMLAttribute where Element_ID = AElementID",
paramsValue
);
try
{
while (attributes.Next())
{
using (IRow row = attributes.Select())
{
string alias = (string)row["NamespaceAlias"];
if (alias != String.Empty)
{
alias = alias + ":";
}
writer.WriteAttributeString(alias + (string)row["Name"], (string)row["Value"]);
}
}
}
finally
{
((IServerProcess)program.ServerProcess).CloseCursor(attributes);
}
// Write the child content and elements
IServerCursor children =
(IServerCursor)((IServerProcess)program.ServerProcess).OpenCursor
(
@"
(XMLContent where Element_ID = AElementID over { Element_ID, Sequence })
union
(
XMLElementParent where Parent_Element_ID = AElementID over { Parent_Element_ID, Sequence }
rename { Parent_Element_ID Element_ID }
)
left join (XMLContent rename { Element_ID Content_Element_ID, Sequence Content_Sequence }) by Element_ID = Content_Element_ID and Sequence = Content_Sequence
left join (XMLElementParent rename { Element_ID Child_Element_ID, Sequence Child_Sequence }) by Element_ID = Parent_Element_ID and Sequence = Child_Sequence
order by { Element_ID, Sequence }
" ,
paramsValue
);
try
{
while (children.Next())
{
using (IRow row = children.Select())
{
if (row.HasValue("Content_Element_ID")) // Content
{
if ((byte)row["Type"] == 0)
{
writer.WriteString((string)row["Content"]);
}
else
{
writer.WriteCData((string)row["Content"]);
}
}
else // Child element
{
WriteElement(program, writer, (Guid)row["Child_Element_ID"]);
}
}
}
}
finally
{
((IServerProcess)program.ServerProcess).CloseCursor(children);
}
// Write the end element
writer.WriteEndElement();
}
public override void Hit()
{
base.Hit();
DataParam.AddCoin(1);
SoundController.instance.PlaySound(soundGame.soundEatCoin);
}
