public async Task GetPreparationsByName()
{
//Arrange
var expected = new Preparation()
{
Name = "Hello world", ActiveIngredient = "Limon"
};
var result = JsonConvert.SerializeObject(new Dictionary <string, IGood>()
{
{ "data", expected }
});
var mok = new Mock <IExternalDb>();
(string, string)p = ("name", "");
mok.Setup(e => e.AskService(It.IsAny <string>(), HttpMethod.Get, new[]
{
p
})).
Returns(Task.FromResult(result));
var streinger = new Streinger(mok.Object);
//Actual
var preparation = await streinger.Preparations("");
//Assert
Assert.NotNull(preparation);
Assert.Equal(expected, preparation);
}
/// <inheritdoc/>
public string ToDelimitedString()
{
CultureInfo culture = CultureInfo.CurrentCulture;
return(string.Format(
culture,
StringHelper.StringFormatSequence(0, 19, Configuration.FieldSeparator),
Id,
SequenceNumberTestObservationMasterFile.HasValue ? SequenceNumberTestObservationMasterFile.Value.ToString(Consts.NumericFormat, culture) : null,
DerivedSpecimen,
ContainerDescription != null ? string.Join(Configuration.FieldRepeatSeparator, ContainerDescription.Select(x => x.ToDelimitedString())) : null,
ContainerVolume != null ? string.Join(Configuration.FieldRepeatSeparator, ContainerVolume.Select(x => x.ToString(Consts.NumericFormat, culture))) : null,
ContainerUnits != null ? string.Join(Configuration.FieldRepeatSeparator, ContainerUnits.Select(x => x.ToDelimitedString())) : null,
Specimen?.ToDelimitedString(),
Additive?.ToDelimitedString(),
Preparation?.ToDelimitedString(),
SpecialHandlingRequirements?.ToDelimitedString(),
NormalCollectionVolume?.ToDelimitedString(),
MinimumCollectionVolume?.ToDelimitedString(),
SpecimenRequirements?.ToDelimitedString(),
SpecimenPriorities != null ? string.Join(Configuration.FieldRepeatSeparator, SpecimenPriorities) : null,
SpecimenRetentionTime?.ToDelimitedString(),
SpecimenHandlingCode != null ? string.Join(Configuration.FieldRepeatSeparator, SpecimenHandlingCode.Select(x => x.ToDelimitedString())) : null,
SpecimenPreference,
PreferredSpecimenAttribtureSequenceId.HasValue ? PreferredSpecimenAttribtureSequenceId.Value.ToString(Consts.NumericFormat, culture) : null,
TaxonomicClassificationCode != null ? string.Join(Configuration.FieldRepeatSeparator, TaxonomicClassificationCode.Select(x => x.ToDelimitedString())) : null
).TrimEnd(Configuration.FieldSeparator.ToCharArray()));
}
/// <summary>
/// Process the Preparations sent by a Meal Plan. These are added if new (PreparationId < 1)
/// Updated if PreparationId > 0
/// </summary>
/// <param name="mealPlanId"></param>
/// <param name="preparations"></param>
public void ProcessList(int mealPlanId, List <PreparationViewModel> preparations)
{
foreach (PreparationViewModel preparationDisplay in preparations)
{
Preparation preparation = new Preparation();
preparation.PreparationId = preparationDisplay.PreparationId;
preparation.MealPlanId = mealPlanId;
preparation.Sequence = preparationDisplay.Sequence;
preparation.Instruction = preparationDisplay.Instruction;
preparation.Active = preparationDisplay.Active;
preparation.Created = DateTime.Now;
using (var dbContext = new ApplicationDbContext())
{
if (preparationDisplay.PreparationId > 0)
{
dbContext.Entry(preparation).State = EntityState.Modified;
}
else
{
preparation.Created = DateTime.Now;
dbContext.Preparations.Add(preparation);
}
dbContext.SaveChanges();
}
}
}
public void testFunc()
{
subtext.text = "";
Debug.Log("a");
int page = ((ButtonUpdatePage.recipePage / 2) - 1);
if (page < 0)
{
instructions.text = ("Pick a valid recipe!");
}
else
{
currentPrep = prep[page];
if (!startedPrep && currentPrep.steps.Length > 0)
{
Debug.Log("starting preparation stage");
StartCoroutine(StartPrep());
startedPrep = true;
}
else
{
Debug.Log("0 prep stages found");
if (currentPrep.steps.Length == 0)
{
finishPrep();
}
}
}
}
protected void BuildRecipe()
{
Recipe.Instructions = Instructions.FromDelimited();
Recipe.Ingredients = Ingredients.FromDelimited();
Recipe.Preparation = Preparation.FromDelimited();
Recipe.Keywords = Keywords.FromDelimited();
}
private Generated.Preparation TranslatePreparationLocalToGP(Preparation prepLocal)
{
Generated.Preparation prepGP = new Generated.Preparation();
try
{
if (prepLocal != null)
{
prepGP.Description = prepLocal.Description;
prepGP.DescriptionAbbreviation = prepLocal.DescriptionAbbreviation;
prepGP.IsPreparation = prepLocal.IsPreparation;
prepGP.LocalEpisodeType = prepLocal.LocalEpisodeType;
prepGP.LocalEpisodeId = prepLocal.LocalEpisodeId;
prepGP.LocalServiceId = prepLocal.LocalServiceId;
prepGP.NumCopies = prepLocal.NumCopies;
prepGP.PreparationDocumentLoaded = prepLocal.PreparationDocumentLoaded;
prepGP.PreparationDocument = prepLocal.PreparationDocument;
prepGP.Template = prepLocal.Template;
}
}
catch (Exception ex)
{
Debug.WriteLine("Erro a realizar o convert de Preparation (Local) para Preparation (GP)");
}
return(prepGP);
}
private Preparation TranslatePreparationGPToLocal(Generated.Preparation prepGP)
{
Preparation prepLocal = new Preparation();
try
{
if (prepGP != null)
{
prepLocal.Description = prepGP.Description;
prepLocal.DescriptionAbbreviation = prepGP.DescriptionAbbreviation;
prepLocal.IsPreparation = prepGP.IsPreparation.HasValue ? prepGP.IsPreparation.Value : true;
prepLocal.LocalEpisodeType = prepGP.LocalEpisodeType;
prepLocal.LocalEpisodeId = prepGP.LocalEpisodeId;
prepLocal.LocalServiceId = prepGP.LocalServiceId;
prepLocal.NumCopies = prepGP.NumCopies.HasValue ? prepGP.NumCopies.Value : 1;
prepLocal.PreparationDocumentLoaded = prepGP.PreparationDocumentLoaded.HasValue ? prepGP.PreparationDocumentLoaded.Value : false;
prepLocal.PreparationDocument = prepGP.PreparationDocument;
prepLocal.Template = prepGP.Template;
}
}
catch (Exception ex)
{
Debug.WriteLine("Erro a realizar o convert de Preparation (GP) para Preparation (local)");
}
return(prepLocal);
}
/// <summary>
/// Get a Preparation based on Id
/// </summary>
/// <param name="preparationId"></param>
/// <returns></returns>
public Preparation Get(int preparationId)
{
using (var dbContext = new ApplicationDbContext())
{
Preparation preparation = new Preparation();
preparation = dbContext.Preparations.Where(x => x.PreparationId == preparationId).Single();
return(preparation);
}
}
public override void UntimedPrepare()
{
if (preparation == null)
{
preparation = new Preparation(count);
}
tree = makeTree(count);
}
public NextIssuePreparation(string text)
{
_page = new SectionedArticle <Section>(text, 2);
Sections = new Preparation(_page.Prefix);
if (_page.Count > 1)
{
NewSections = new Preparation(_page.Last().Text);
}
}
private void SetNewModel()
{
if (_preparation == null)
{
_preparation = new Preparation();
}
_preparation.ID = 0;
_preparation.IsDel = 1;
}
private void AddPreparation()
{
Preparation preparation = new Preparation()
{
ID = 0
};
ShowFileForm(preparation);
}
public void StartSingleBattle()
{
Preparation.Initialize(GameMode.Single);
Preparation.InitEnemy();
UI.OnBattle();
// 3 2 1...
Battle.StartBattle(GameMode.Single);
}
void Start()
{
animator = GameObject.Find("Camera").GetComponent <MenuAnimator> ();
itemController = GameObject.Find("Canvas").GetComponent <ItemController>();
pathFollow = GameObject.Find("Camera").GetComponent <PathFollow> ();
prepareObject = GameObject.Find("GameController").GetComponent <Preparation> ();
especObject = GameObject.Find("espectrofotometro").GetComponent <Espectrofotometro> ();
currentState = GameState.none;
}
private SandwichMachine()
{
BreadSelection = new BreadSelection(this);
CondimentSelection = new CondimentSelection(this);
Payment = new Payment(this);
Preparation = new Preparation(this);
OutOfService = new OutOfService(this);
Current = BreadSelection;
}
private void ClearForm()
{
_preparation = new Preparation();
SetNewModel();
bsPreparation.DataSource = _preparation;
bsPreparation.EndEdit();
txtpCode.Focus();
}
/// <summary>
/// Get a single Preparation View Model
/// </summary>
/// <param name="preparationId"></param>
/// <returns></returns>
public PreparationViewModel GetDisplay(int preparationId)
{
Preparation preparation = Get(preparationId);
PreparationViewModel preparationViewModel = new PreparationViewModel();
preparationViewModel.PreparationId = preparation.PreparationId;
preparationViewModel.MealPlanId = preparation.MealPlanId;
preparationViewModel.Instruction = preparation.Instruction;
preparationViewModel.Active = preparation.Active;
return(preparationViewModel);
}
public int InsertPreparation(Preparation pPreparation)
{
try
{
return(_AD.InsertPreparation(pPreparation));
}
catch (Exception ex)
{
throw;
}
}
private void EditListRow(int iRowIndex)
{
Preparation preparation = GetListRowModel(iRowIndex);
if (preparation == null)
{
return;
}
ShowFileForm(preparation);
}
private void ShowFileForm(Preparation preparation)
{
using (FrmP2BFile frm = new FrmP2BFile(preparation))
{
frm.ShowDialog();
}
this.Refresh();
Application.DoEvents();
GetListQueryData();
}
public bool UpdatePreparation(Preparation pPreparation)
{
try
{
_AD.UpdatePreparation(pPreparation);
return(true);
}
catch (Exception ex)
{
throw;
}
}
public void WhenCastSpell()
{
DeadlyPoison deadlyPoison = SetTestedCardInHand <DeadlyPoison>();
BladeFlurry bladeFlurry = SetTestedCardInHand <BladeFlurry>();
Preparation preparation = SetTestedCardInHand <Preparation>();
Sprint sprint = SetTestedCardInHand <Sprint>();
GameResult <GameContextOutput> res = proxy.CastSpell(gameContext.GameCode, gameContext.GetActivationUserContext().UserCode, preparation.CardInGameCode, -1) as GameResult <GameContextOutput>;
Xunit.Assert.True(res.code == (int)OperateResCodeEnum.成功);
Xunit.Assert.True(deadlyPoison.Cost == -2 && bladeFlurry.Cost == -1 && sprint.Cost == 4);
Xunit.Assert.True(preparation.Cost == 0);
}
public void StartMultiBattle()
{
Setting.MyDeck.Clear();
Setting.EnemyDeck.Clear();
Preparation.InitMyDeck();
Preparation.InitMySummoner();
Client client = new Client();
client.Start();
client.SendClientData(UserInfo.nickName, UserData.TierScore);
UI.OnBattle();
}
public void UpdatePreparation(Preparation pPreparation)
{
string sql = @"[spUpdatePreparation] '{0}', '{1}', '{2}', '{3}'";
sql = string.Format(sql, pPreparation.Id, pPreparation.Description, pPreparation.Status.Id,
pPreparation.ModificationUser);
try
{
_MB.EjecutarSQL(_CN, sql);
}
catch (Exception err)
{
throw err;
}
}
public int InsertPreparation(Preparation pPreparation)
{
string sql = @"[spInsertPreparation] '{0}', '{1}', '{2}', '{3}'";
sql = string.Format(sql, pPreparation.Description, pPreparation.Status.Id,
pPreparation.CreatorUser, pPreparation.ModificationUser);
try
{
return(_MB.EjecutarSQL(_CN, sql));
}
catch (Exception err)
{
throw err;
}
}
private Preparation GetListRowModel(int iRowIndex)
{
string strErr = string.Empty;
Preparation preparation = new Preparation();
preparation.ID = lstPreparation[iRowIndex].ID;
if (!Basic_Func.GetPreparationByID(ref preparation, ref strErr))
{
Common.Common_Func.ErrorMessage(strErr, "读取失败");
GetListQueryData();
return(null);
}
return(preparation);
}
public async Task RemoveGoodWithInValidParam()
{
var mok = new Mock <IExternalDb>();
mok.Setup(e => e.AskService(It.IsAny <string>(), HttpMethod.Get, null))
.Returns(Task.FromResult(@""));
var streinger = new Streinger(mok.Object);
var prep = new Preparation("INVALID", "", "", "", "Буг", "");
var good = new Good {
Price = 0, Supplier = null, Product = prep
};
//Actual
//Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() => await streinger.RemoveGood(good));
}
public async Task AddGoodWithInValidParam()
{
var mok = new Mock <IExternalDb>();
mok.Setup(e => e.AskService(It.IsAny <string>(), HttpMethod.Get, null))
.Returns(Task.FromResult(@""));
var streinger = new Streinger(mok.Object);
var prep = new Preparation("INVALID", "", "", "", "Буг", "");
var good = new Good {
Price = 0, Supplier = new Supplier(), Product = prep
};
//Actual
var val = await streinger.AddGood(good);
//Assert
Assert.False(val);
}
public FrmP2BFile(Preparation model)
{
if (model == null)
{
model = new Preparation();
}
_preparation = model;
if (model.ID == 0)
{
SetNewModel();
}
_back = Common.Common_Func.ConvertToModel <Preparation>(_preparation);
InitializeComponent();
bsPreparation.DataSource = _preparation;
}
public async Task <ServiceReturn <List <Preparation> > > GetPreparationsAfterScheduleAsync(AuthenticationType tipoAuth, string facilityId, string IdAppointment, string successMessage = "", string errorMessage = "")
{
var uiMessages = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(errorMessage))
{
uiMessages.Add(ServiceReturnHandling.GenericMessageKey, errorMessage);
}
else
{
uiMessages.Add(ServiceReturnHandling.GenericMessageKey, "Não é possível obter lista de preparações");
}
if (!string.IsNullOrEmpty(successMessage))
{
uiMessages.Add(ServiceReturnHandling.SuccessMessageKey, successMessage);
}
List <Preparation> preps = null;
try
{
string baseUrl = await CommunicationManager.ServiceManager.GetServiceEndpoint("GP_BASE_URL");
Generated.AppointmentClient sc = new Generated.AppointmentClient(baseUrl, await CommunicationManager.Instance.GetHttpClientWithToken(tipoAuth, new HttpClient()));
var prepIni = await sc.GetPreparationsAfterScheduleAsync(facilityId, IdAppointment, GetGPAppVersion());
if (prepIni != null)
{
preps = new List <Preparation>();
foreach (var item in prepIni)
{
Preparation prep = TranslatePreparationGPToLocal(item);
prep.FacilityId = facilityId; // facility nao vem mapeada.. adicionada manualmente pois é necessária no GetLoadPreparationObjectAsync (obter doc da preparação)
preps.Add(prep);
}
}
return(ServiceReturnHandling.BuildSuccessCallReturn <List <Preparation> >(preps, uiMessages));
}
catch (Exception ex)
{
return(ServiceReturnHandling.HandleException <List <Preparation> >(ex, uiMessages));
}
}
