private static ClassDeclarationSyntax CreateClass(
ClassDeclarationSyntax parentClass,
ConstructorDeclarationSyntax constructor)
{
ObjectCreationExpressionSyntax CreateMoq(TypeSyntax moqType) =>
EGH.CreateObject(
moqType,
SF.Argument(
EGH.MemberAccess(
GH.Identifier("MockBehavior"),
GH.Identifier("Strict"))));
var mi = new MethodInspector(constructor);
var recordBuilder = new RecordBuilder($"{mi.Name}Test")
.AddModifiers(Modifiers.Public);
foreach (var p in mi.Parameters)
{
var mockedType = GetMockedType(p.Type);
var moqType = GH.GenericName("Mock", mockedType);
recordBuilder.AddField(moqType, MockName(p.Name), CreateMoq(moqType));
}
recordBuilder.AddMethod(GenerateCreateSut(parentClass, mi));
return(recordBuilder.Build());
}
private static ClassDeclarationSyntax CreateClass(
SemanticModel semanticModel,
MethodDeclarationSyntax method)
{
var mi = new MethodInspector(method);
var semanticQuery = mi.CreateSemanticQuery(semanticModel);
var isTaskReturn = SymbolSemanticQuery.IsTask(
semanticQuery.GetReturnType().Symbol);
var parameters = mi.Parameters.Select(par => par.Type).ToList();
var recordBuilder = new RecordBuilder($"{mi.Name}Command")
.AddModifiers(Modifiers.Public)
.AddProperties(
mi.Parameters
.Select(p => (p.Type, p.Name)).ToArray());
if (isTaskReturn.IsTask())
{
AddTaskUtilities(recordBuilder, Types.Bool);
}
else if (isTaskReturn.IsTypedTask(out var typeSymbol))
{
AddTaskUtilities(
recordBuilder,
GH.Identifier(SymbolSemanticQuery.GetName(typeSymbol)));
}
return(recordBuilder.Build());
}
public int InsertAdminGHWithTrans(DbTransaction trans, GH obj)
{
var iRet = defaultDB.ExecuteScalar(trans, "sp_GH_InsertInsertAdminGHWithTrans"
, obj.CodeId, obj.Amount, obj.CurrentAmount, obj.CreateDate, obj.Status);
return(Convert.ToInt32(iRet));
}
private static MethodDeclarationSyntax GenerateCreateSut(
ClassDeclarationSyntax classDeclaration,
MethodInspector constructorInspector)
{
var methodBuilder = new MethodBuilder(GH.IdentifierToken("CreateSut"))
.Modifiers(Modifiers.Private);
var constructorParameters = constructorInspector
.Parameters
.Select(p => SF.Argument(
EGH.MemberAccess(
EGH.ThisMemberAccess(
GH.Identifier(MockName(p.Name))
),
GH.Identifier("Object")
)
)
);
methodBuilder.ArrowBody(
EGH.Arrow(
EGH.CreateObject(
SF.IdentifierName(classDeclaration.Identifier),
constructorParameters.ToArray())));
return(methodBuilder.Build());
}
public ParameterSyntax Build()
{
return(SF.Parameter(
GH.EmptyAttributeList(),
SF.TokenList(this.modifiers ?? Enumerable.Empty <SyntaxToken>()),
this.type,
this.identifier,
default(EqualsValueClauseSyntax)));
}
public Node(Pos pos, int g, int h, Node father)
{
this.pos = pos;
this.father = father;
this.gh = new GH()
{
g = g + (IsSameD ? 0 : 1), h = h
};
}
public ActionResult Update(int iMaSP, FormCollection f)
{
List <GH> lstGioHang = takeGH();
GH sanpham = lstGioHang.SingleOrDefault(n => n.iMaLT == iMaSP);
if (sanpham != null)
{
sanpham.iSoluong = int.Parse(f["txtSoluong"].ToString());
}
return(RedirectToAction("GioHang"));
}
public MethodBuilder AddParameter(TypeSyntax typeSyntax, SyntaxToken identifier)
{
Parameters(
SyntaxFactory.Parameter(
GH.EmptyAttributeList(),
SF.TokenList(),
typeSyntax,
identifier,
default(EqualsValueClauseSyntax)));
return(this);
}
public void Many2ManyNoCopyTest()
{
G g = new G();
H h = new H();
GH gh = new GH {
G = g, H = h
};
var copyOfg = g.Copy(EntityGraphs.SimpleGraphShape3);
var g1 = g.EntityGraph(EntityGraphs.SimpleGraphShapeFull);
var g2 = copyOfg.EntityGraph(EntityGraphs.SimpleGraphShapeFull);
Assert.IsFalse(g1.IsCopyOf(g2));
Assert.IsTrue(copyOfg.GHSet.Count() == 0);
}
public ActionResult XoaGioHang(int iMaSP)
{
List <GH> lstGioHang = takeGH();
GH sanpham = lstGioHang.SingleOrDefault(n => n.iMaLT == iMaSP);
if (sanpham != null)
{
lstGioHang.RemoveAll(n => n.iMaLT == iMaSP);
return(RedirectToAction("GioHang"));
}
if (lstGioHang.Count == 0)
{
//return RedirectToAction("Index", "MyWeb");
}
return(RedirectToAction("GioHang"));
}
private static void AddTaskUtilities(
RecordBuilder recordBuilder,
TypeSyntax tcsType)
{
var tcs = GeneratorHelper.GenericName(
"TaskCompletionSource",
tcsType);
var initializer = ExpressionGenerationHelper.CreateObject(tcs);
recordBuilder.AddField(tcs, "result", initializer);
var resolveMethod = new MethodBuilder(GH.IdentifierToken("Resolve"))
.Modifiers(Modifiers.Public)
.AddParameter(tcsType, GH.IdentifierToken("value"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetResult"),
SF.Argument(GH.Identifier("value")))
.Build())
.Build();
var cancelMethod = new MethodBuilder(GH.IdentifierToken("Cancel"))
.Modifiers(Modifiers.Public)
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetCanceled"))
.Build())
.Build();
var rejectMethod = new MethodBuilder(GH.IdentifierToken("Reject"))
.Modifiers(Modifiers.Public)
.AddParameter(GH.Identifier("Exception"), GH.IdentifierToken("exc"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetException"),
SF.Argument(GH.Identifier("exc")))
.Build())
.Build();
recordBuilder.AddMethod(resolveMethod);
recordBuilder.AddMethod(cancelMethod);
recordBuilder.AddMethod(rejectMethod);
}
void Start()
{
//Lr = GetComponent<LineRenderer>();
//Rend = GetComponent<Renderer>();
state_ = PlayerState.STATE_RUNNING;
m_Collider = GetComponent <Collider>();
rb = GetComponent <Rigidbody>();
//abstand zum boden
distanceToGround = m_Collider.bounds.extents.y;
playerStartRotation = transform.rotation;
lookRight = transform.rotation;
lookLeft = lookRight * Quaternion.Euler(0, 180, 0);
gH = GetComponent <GH>();
// rb.freezeRotation = true;
}
public ActionResult ThemGioHang(int iMaLT, string strURL)
{
List <GH> lstGioHang = takeGH();
GH sanpham = lstGioHang.Find(n => n.iMaLT == iMaLT);
if (sanpham == null)
{
sanpham = new GH(iMaLT);
lstGioHang.Add(sanpham);
return(Redirect(strURL));
}
else
{
sanpham.iSoluong++;
return(Redirect(strURL));
}
}
public void Many2ManyFullCopyTest()
{
G g = new G();
H h = new H();
GH gh = new GH {
G = g, H = h
};
var copyOfg = g.Copy(EntityGraphs.SimpleGraphShapeFull);
var g1 = g.EntityGraph(EntityGraphs.SimpleGraphShapeFull);
var g2 = copyOfg.EntityGraph(EntityGraphs.SimpleGraphShapeFull);
Assert.IsTrue(g1.IsCopyOf(g2));
// Check that the m2m association to h is now an association to a copy of h
var copyOfH = copyOfg.GHSet.First().H;
Assert.IsTrue(copyOfH != h);
}
public void Many2ManyShallowCopyTest()
{
G g = new G();
H h = new H();
GH gh = new GH {
G = g, H = h
};
var copyOfg = g.Copy(EntityGraphs.SimpleGraphShape2);
var g1 = g.EntityGraph(EntityGraphs.SimpleGraphShapeFull);
var g2 = copyOfg.EntityGraph(EntityGraphs.SimpleGraphShapeFull);
Assert.IsFalse(g1.IsCopyOf(g2));
// Check that the m2m association to h still exists, because h is not copied
var copyOfH = copyOfg.GHSet.First().H;
Assert.IsTrue(copyOfH == h);
}
private async Task SetInsertValue <M>(M m, OptionEnum option, int index)
{
var props = SC.GetModelProperys(m.GetType(), this);
var columns = (SC.GetColumnInfos(SC.GetKey(typeof(M).FullName, Conn.Database), this)).GetAwaiter().GetResult();
foreach (var prop in props)
{
var val = GH.GetTypeValue(prop.PropertyType, prop, m);
AddConditions(new DicModel
{
ColumnOne = prop.Name,
Param = prop.Name,
ParamRaw = prop.Name,
CsValue = val,
ValueType = prop.PropertyType,
ColumnType = columns.First(it => it.ColumnName.Equals(prop.Name, StringComparison.OrdinalIgnoreCase)).DataType,
Action = ActionEnum.Insert,
Option = option,
TvpIndex = index
});
}
}
public ActionResult AddToCart(string id)
{
var sp = db.SanPhams.Where(x => x.MaSanPham == id).FirstOrDefault();
if (sp == null)
{
return(Json(false));
}
var GH = Session[CartName] as List <GioHang>;
if (GH == null)
{
GH = new List <GioHang>();
Session[CartName] = GH;
}
var exists = GH.FirstOrDefault(gh => gh.iId == id);
if (exists == null)
{
GioHang gh = new GioHang();
gh.iId = sp.MaSanPham;
gh.iName = sp.TenSanPham;
gh.iImage = sp.HinhMinhHoa;
gh.iSoLuong = 1;
gh.iPrice = sp.DonGia;
GH.Add(gh);
}
else
{
exists.iSoLuong++;
}
var model = PrepareCartModel();
return(PartialView("MiniCart", model));
}
/// <summary>
/// This method adds a new datapoint using the Simulation model and the datahandler.
/// </summary>
private void Update()
{
for (int i = 0; i < _scale; i++)
{
currentData.time += interval;
simulationDataHandler.addDataPoint(SimulationModel.Update(interval / 1000));
}
currentData = simulationDataHandler.SimulationData.Last();
if (selected && running)
{
this.stop();
foreach (GraphHandler GH in graphHandlers)
{
GH.Update(currentData);
}
if (Updated != null)
{
Updated();
}
this.start();
}
}
void Start()
{
Lr = GetComponent <LineRenderer>();
player = GetComponent <HCPlayerController>();
grapplingHook = GetComponent <GH>();
}
public HttpResponseMessage GetYourFriendPlans(Int32 UserID, Int16 Pageindex, Int16 Pagesize)
{
try
{
var users = (from A in db.UserFriends
join B in db.UserGoing on A.Matched_UserID equals B.UserID into AB
from B in AB.DefaultIfEmpty()
join C in db.TourDate on B.TourDateID equals C.TourDateID into BD
from C in BD.DefaultIfEmpty()
where A.UserID == UserID && A.Matched_UserID != 0 && B.RecordStatus == "Going" && C.TicketingEventID == null
select B.TourDateID).ToList();
int RemainingRecord = Pagesize;
var _list = (from A in db.TourDate
join B in db.Artists on A.ArtistID equals B.ArtistID into AB
from B in AB.DefaultIfEmpty()
join C in db.Venue on A.VenueID equals C.VenueID into AC
from C in AC.DefaultIfEmpty()
where users.Contains(A.TourDateID) && A.Tour_Utcdate > DateTime.Now && A.IsDeleted == false
select new ViewYourFreiendplanlst()
{
TourDateID = A.TourDateID,
ArtistID = A.ArtistID,
ArtistName = B.ArtistName,
ImageURL = B.ImageURL,
BannerImage_URL = B.BannerImage_URL,
Datetime_Local = A.Datetime_Local.Value,
VenueName = C.VenueName,
Going = (from G in db.UserFriends
join H in db.Users on G.Matched_UserID equals H.UserID into GH
from H in GH.DefaultIfEmpty()
join I in db.UserGoing on H.UserID equals I.UserID into HI
from I in HI.DefaultIfEmpty()
where G.UserID == UserID && I.TourDateID == A.TourDateID && H.RecordStatus == "Going"
select new ViewFriendPlans()
{
Email = H.Email,
ImageURL = H.ImageURL,
ThumbnailURL = H.ThumbnailURL,
UserID = H.UserID,
UserName = H.UserName
}).ToList()
}).OrderBy(x => x.ArtistID).Skip(Pageindex * Pagesize).Take(Pagesize).ToList();
RemainingRecord = RemainingRecord - _list.Count;
var goingList = (from A in db.UserFriends
join B in db.UserGoing on A.Matched_UserID equals B.UserID into AB
from B in AB.DefaultIfEmpty()
where A.UserID == UserID && A.Matched_UserID > 0 &&
B.RecordStatus == "Going"
select new
{
TourDateID = B.TourDateID
}).Distinct().ToList();
List <int?> userlist1 = new List <int?>();
foreach (var item in goingList)
{
userlist1.Add(Convert.ToInt32(item.TourDateID));
}
if (RemainingRecord > 0)
{
var list2 = (from A in db.TicketingEventTicketConfirmation
join B in db.TicketingEventsNew on A.EventID equals B.EventID into AB
from B in AB.DefaultIfEmpty()
join C in db.Artists on B.ArtistId equals C.ArtistID into BC
from C in BC.DefaultIfEmpty()
join D in db.Venue on B.VenueName equals D.VenueName into CD
from D in CD.DefaultIfEmpty()
join E in db.TourDate on B.EventID equals E.TicketingEventID into DE
from E in DE.DefaultIfEmpty()
where A.EventID > 0 && userlist1.Contains(A.TourDateID)
select new ViewYourFreiendplanlst()
{
TourDateID = E.TourDateID,
// EventID = A.EventID,
ArtistID = B.ArtistId,
ArtistName = C.ArtistName,
ImageURL = C.ImageURL,
BannerImage_URL = C.BannerImage_URL,
//StartDate = B.StartDate,
//StartTime = B.StartTime,
VenueID = D.VenueID,
VenueName = D.VenueName,
Datetime_Local = B.StartDate.Value
}).Distinct().OrderBy(x => x.ArtistID).Skip(0).Take(RemainingRecord).ToList();
foreach (var item in list2)
{
item.Going = (from G in db.UserFriends
join H in db.Users on G.Matched_UserID equals H.UserID into GH
from H in GH.DefaultIfEmpty()
join I in db.UserGoing on H.UserID equals I.UserID into HI
from I in HI.DefaultIfEmpty()
where G.UserID == UserID && I.TourDateID == item.TourDateID && I.RecordStatus == "Going" && G.Matched_UserID > 0
select new ViewFriendPlans()
{
Email = H.Email,
ImageURL = H.ImageURL,
ThumbnailURL = H.ThumbnailURL,
UserID = H.UserID,
UserName = H.UserName
}).Distinct().ToList();
item.GoingCount = item.Going.Count();
item.Date_Local = item.Datetime_Local.ToString("d");
}
_list.AddRange(list2);
}
return(Request.CreateResponse(HttpStatusCode.OK, JsonResponse.GetResponse(ResponseCode.Success, _list, "FriendPlans")));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, JsonResponse.GetResponse(ResponseCode.Info, ex.Message, "FriendPlans")));
}
}
public void InsertWithTransaction(COMMAND _command, List <COMMAND_DETAIL> _lstCommandDetails, List <GH_Info> _lstGH_Admin)
{
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Suppress))
{
using (DbConnection connection = defaultDB.CreateConnection())
{
connection.Open();
try
{
using (DbTransaction transaction = connection.BeginTransaction())
{
try
{
var dhCommand = new COMMAND_DETAIL_DH();
var dhPH = new PH_DH();
var dhGH = new GH_DH();
// insert admin GH
foreach (var gh in _lstGH_Admin)
{
var oGH = new GH {
CodeId = gh.CodeId, Amount = gh.Amount, CreateDate = gh.CreateDate, CurrentAmount = gh.CurrentAmount, Status = (int)Constants.GH_STATUS.Waiting
};
int iGHID = dhGH.InsertAdminGHWithTrans(transaction, oGH);
foreach (var com in _lstCommandDetails)
{
if (com.GH_ID == 0 && com.CodeId_To == gh.CodeId)
{
com.GH_ID = iGHID;
}
}
}
// insert command
int commandId = InsertWithTrans(transaction, _command);
// insert GH cua acc admin dua vao
// update GH_ID vao danh sach
// insert command details
foreach (var o in _lstCommandDetails)
{
o.CommandID = commandId;
dhCommand.InsertItemWithTrans(transaction, o);
dhPH.UpdateStatusWithTrans(transaction, (int)o.PH_ID, (int)Constants.PH_STATUS.Pending);
dhGH.UpdateStatusWithTrans(transaction, (int)o.GH_ID, (int)Constants.GH_STATUS.Pending);
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
}
finally
{
connection.Close();
}
}
scope.Complete();
}
}
public void UpdateItem(GH obj)
{
defaultDB.ExecuteNonQuery("sp_GH_Update"
, obj.ID, obj.CodeId, obj.Amount, obj.CurrentAmount, obj.CreateDate, obj.Status);
}
public void InsertItem(GH obj)
{
defaultDB.ExecuteNonQuery("sp_GH_Insert"
, obj.CodeId, obj.Amount, obj.CurrentAmount, obj.CreateDate, obj.Status);
}
public void UpdateItem(GH obj)
{
ctl.UpdateItem(obj);
}
public void InsertItem(GH obj)
{
ctl.InsertItem(obj);
}
public async Task Test2()
{
// Arrange
var text = @"
using System;
using System.Threading.Tasks;
namespace RefactorClasses.Analysis.Test
{
[StateMachine(ContextType = typeof(ContextBase), StateType = typeof(StateBase), TriggerType = (typeof(TriggerBase)))]
public class StateMachineImpl
{
public void DoSomething(
int a,
Test1 testClass, string fdeee)
{
}
public async Task<int> TaskMethodReturningSomething(int a, float b)
{
return 10;
}
public System.Threading.Tasks.Task AsyncOperationsSupport(int a, float b)
{
return Task.CompletedTask;
}
public async Task TaskMethod(int a, float b)
{
return;
}
public async Task TaskMethodWithArrays(int[] a, float[] b)
{
return;
}
public async Task TaskMethodWithTuples((int, float) a, float[] b)
{
return;
}
private void PrintSomething() {}
}
public class TriggerBase { }
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
public sealed class StateMachineAttribute : Attribute
{
public Type StateType { get; set; }
public Type TriggerType { get; set; }
public Type ContextType { get; set; }
}
}";
var tree = CSharpSyntaxTree.ParseText(text);
var compilation = TestHelpers.CreateCompilation(tree);
var semanticModel = compilation.GetSemanticModel(tree);
var classDeclaration = TestHelpers.FindFirstClassDeclaration(await tree.GetRootAsync());
var classInspector = new ClassInspector(classDeclaration);
var semanticInspector = classInspector.CreateSemanticQuery(semanticModel);
bool foundAttribute = semanticInspector.TryFindFirstAttributeMatching(
"StateMachineAttribute", out var atData);
var triggerType = atData
?.NamedArguments
.FirstOrDefault(kvp => kvp.Key.Equals("TriggerType"));
if (triggerType == null)
{
return;
}
var methods = classInspector.FindMatchingMethods(
mi => mi.Check(m => m.IsPublic() && !m.IsStatic()).Passed);
foreach (var method in methods)
{
var msq = method.CreateSemanticQuery(semanticModel);
var returnType = msq.GetReturnType();
var isTaskReturn = IsTask(returnType.Symbol);
var parameters = method.Parameters.Select(par => par.Type).ToList();
// TODO: will throw if array
var triggerTypeName = triggerType.Value.Value.Value as INamedTypeSymbol;
if (triggerTypeName == null)
{
return;
}
var recordBuilder = new RecordBuilder(method.Name)
.AddModifiers(Modifiers.Public)
.AddBaseTypes(GeneratorHelper.Identifier(triggerTypeName.Name))
.AddProperties(
method.Parameters
.Select(p => (p.Type, p.Name)).ToArray());
if (isTaskReturn.Value.IsTask())
{
var boolTcs = GeneratorHelper.GenericName(
"TaskCompletionSource",
Types.Bool);
var initializer = ExpressionGenerationHelper.CreateObject(boolTcs);
recordBuilder.AddField(boolTcs, "result", initializer);
var resolveMethod = new MethodBuilder(GH.IdentifierToken("Resolve"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetResult"),
SF.Argument(GH.Identifier("true")))
.Build())
.Build();
var cancelMethod = new MethodBuilder(GH.IdentifierToken("Cancel"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetCanceled"))
.Build())
.Build();
var rejectMethod = new MethodBuilder(GH.IdentifierToken("Cancel"))
.AddParameter(GH.Identifier("Exception"), GH.IdentifierToken("exc"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetException"),
SF.Argument(GH.Identifier("exc")))
.Build())
.Build();
recordBuilder.AddMethod(resolveMethod);
recordBuilder.AddMethod(cancelMethod);
recordBuilder.AddMethod(rejectMethod);
int ddddd = 0;
}
else if (isTaskReturn.Value.IsTypedTask(out var taskType))
{
var typedTcs = GeneratorHelper.GenericName(
"TaskCompletionSource",
GeneratorHelper.Identifier(taskType.Name));
var initializer = ExpressionGenerationHelper.CreateObject(typedTcs);
recordBuilder.AddField(typedTcs, "result", initializer);
}
var record = recordBuilder.Build();
// TODO: if task is returned -> generate TaskCompletionSource
// and matching methods
var rs = record.ToString();
int a = 10;
}
// Act
// Assert
IsTaskResult?IsTask(ISymbol symbol)
{
var namedSymbol = symbol as INamedTypeSymbol;
if (namedSymbol == null)
{
return(null);
}
if (namedSymbol.Name == "Task" &&
namedSymbol?.ContainingNamespace?.ToString() == "System.Threading.Tasks")
{
var firstTypeArg = namedSymbol.TypeArguments.FirstOrDefault();
if (firstTypeArg != null)
{
return(IsTaskResult.TypedTask(firstTypeArg));
}
else
{
return(IsTaskResult.Task());
}
}
return(IsTaskResult.NotATask());
}
//var tcs = new TaskCompletionSource<int>();
//tcs.TrySetException()
}
