public static Dossier ToDossier(DossierData dossier, IEnumerable <IdentityRole> roles = null)
{
var model = new Dossier
{
Id = dossier.Id,
Name = dossier.Name,
OwnerId = dossier.OwnerId,
Notes = new List <Note>(),
Details = new List <DossierDetail>(),
Watchers = new List <User>()
};
if (dossier.Details != null)
{
model.Details = Converter.ToDossierDetail(dossier.Details)
.ToList();
}
if (dossier.Notes != null)
{
model.Notes = Converter.ToNote(dossier.Notes)
.ToList();
}
if (roles != null)
{
model.Watchers = Converter.ToUser(dossier.Watchers, roles)
.ToList();
}
return(model);
}
public bool Annuler(int dossierReservationId, RaisonAnnulationDossier raisonAnnulationDossier)
{
bool succes = false;
var dossierReservation = new DossierData().GetById(dossierReservationId);
if (dossierReservation != null &&
dossierReservation.RaisonAnnulationDossier == 0 &&
dossierReservation.EtatDossierReservation != EtatDossierReservation.Refuse &&
raisonAnnulationDossier == RaisonAnnulationDossier.Client)
{
dossierReservation.EtatDossierReservation = EtatDossierReservation.Annule;
dossierReservation.RaisonAnnulationDossier = RaisonAnnulationDossier.Client;
if (dossierReservation.Assurances.Where(x => x.TypeAssurance == TypeAssurance.Annulation).Count() > 0)
{
var rembourser = new CarteBancaireService().Rembourser(dossierReservation.NumeroCarteBancaire,
dossierReservation.PrixTotal);
}
new DossierData().Update(dossierReservation);
succes = true;
}
if (dossierReservation != null &&
dossierReservation.RaisonAnnulationDossier == raisonAnnulationDossier &&
dossierReservation.EtatDossierReservation == EtatDossierReservation.Refuse)
{
dossierReservation.EtatDossierReservation = EtatDossierReservation.Annule;
new DossierData().Update(dossierReservation);
succes = true;
}
return(succes);
}
public DossierReservation Ajout(DossierReservation dossierReservation)
{
var dossierData = new DossierData();
dossierData.Ajouter(dossierReservation);
return(dossierReservation);
}
public async Task <IHttpActionResult> Post(string userId, [FromBody] Dossier dossier)
{
var user = await UserManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound());
}
var dossierData = new DossierData()
{
Name = dossier.Name,
OwnerId = user.Id,
Watchers = new List <UserData>()
};
dossierData.Watchers.Add(user);
UoW.DossierRepository.Insert(dossierData);
UoW.Save();
var result = Converter.ToDossier(dossierData);
return(Created(Request.RequestUri, result));
}
protected override void Seed(Lisa.Zuma.BlueJay.Web.Data.BlueJayContext context)
{
// This method will be called after migrating to the latest version.
var userStore = new UserStore <UserData>(context);
var userManager = new UserManager <UserData>(userStore);
var roleStore = new RoleStore <IdentityRole>(context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
var dossier = new DossierData
{
Details = new List <DossierDetailData>(),
Name = "Martijn"
};
var parent = new UserData
{
Type = "PARENT",
UserName = "******"
};
var mentor = new UserData
{
Type = "OTHER",
UserName = "******"
};
try
{
context.SaveChanges();
userManager.Create(parent, "password123");
userManager.Create(mentor, "password123");
// Add default roles
roleManager.Create(new IdentityRole("User"));
roleManager.Create(new IdentityRole("Begeleider"));
roleManager.Create(new IdentityRole("Parent"));
roleManager.Create(new IdentityRole("Admin"));
// Add parent to parent role and user role
userManager.AddToRole(parent.Id, "User");
userManager.AddToRole(parent.Id, "Parent");
userManager.AddToRole(mentor.Id, "User");
userManager.AddToRole(mentor.Id, "Begeleider");
dossier.OwnerId = parent.Id;
parent.Dossiers = new List <DossierData>()
{
dossier
};
context.SaveChanges();
}
catch { }
}
/// <summary>
/// Tries to get the note identified by <paramref name="id"/> and fills <paramref name="noteData"/>
/// with the retrieved note.
/// </summary>
/// <param name="dossierData"></param>
/// <param name="id">The id of the note to retrieve.</param>
/// <param name="dossierDetailData">The note to fill with the retrieval result.</param>
/// <returns></returns>
public static bool TryGetNote(this DossierData dossierData, int id, out NoteData noteData)
{
if (!dossierData.HasNote(id))
{
noteData = null;
return(false);
}
noteData = dossierData.GetNote(id);
return(true);
}
/// <summary>
/// Tries to get the detail identified by <paramref name="id"/> and fills <paramref name="dossierDetailData"/>
/// with the retrieved detail.
/// </summary>
/// <param name="dossierData"></param>
/// <param name="id">The id of the detail to retrieve.</param>
/// <param name="dossierDetailData">The detail to fill with the retrieval result.</param>
/// <returns></returns>
public static bool TryGetDetail(this DossierData dossierData, int id, out DossierDetailData dossierDetailData)
{
if (!dossierData.HasDetail(id))
{
dossierDetailData = null;
return(false);
}
dossierDetailData = dossierData.GetDetail(id);
return(true);
}
private void UpdateDossierFile(FileInfo fi)
{
using (Unpickler unpickler = new Unpickler())
{
using (FileStream fs = fi.OpenRead())
{
DossierData dossier = ParseDossierRawData(fi.Name, unpickler.load(fs));
DossierDB.UpdateDossierData(fi.Name, fi.LastWriteTimeUtc.ToUnixTime(), dossier);
}
}
}
/// <summary>
/// Tries to get the dossier identified by <paramref name="id"/> and fills <paramref name="dossierData"/>
/// with the retrieved dossier.
/// </summary>
/// <param name="noteData"></param>
/// <param name="id">The id of the dossier to retrieve.</param>
/// <param name="dossierData">The dossier to fill with the retrieval result.</param>
/// <returns></returns>
public static bool TryGetDossier(this UserData userData, int id, out DossierData dossierData)
{
if (!userData.HasDossier(id))
{
dossierData = null;
return(false);
}
dossierData = userData.GetDossier(id);
return(true);
}
public static void UpdateDossierData(string filename, int modified, DossierData dossier)
{
int lastBattleTime = DossierDB.GetDossierFileParam(filename, "lastBattleTime");
int newLastBattleTime = dossier.maxLastBattleTime;
ExecuteNonQuery(String.Format("INSERT OR REPLACE INTO DossierCacheFiles VALUES ({0}, {1}, {2})", Q(filename), modified, newLastBattleTime));
if (newLastBattleTime <= 0)
{
return;
}
// update periods
DataRow playerDataRow = ExecuteRow("SELECT 1 FROM Players WHERE playerName=" + Q(dossier.playerName));
ExecuteNonQuery(playerDataRow == null
? String.Format("INSERT INTO Players VALUES({0}, {1}, {1})", Q(dossier.playerName), newLastBattleTime)
: String.Format("UPDATE Players SET last={1} WHERE playerName={0}", Q(dossier.playerName), newLastBattleTime));
// update vehicle stat
if (dossier.vehicles == null)
{
return;
}
Program.Log("UpdateDossierData: " + dossier.playerName);
foreach (DossierVehicleData vd in dossier.vehicles)
{
if (vd.lastBattleTime <= lastBattleTime)
{
continue;
}
VehicleInfoData vi = VehicleInfo.ByVid(vd.vid);
if (vi == null)
{
Program.Log("WARNING: no data for vid=" + vd.vid);
continue;
}
Program.Log(String.Format(" {0}: {1} ({2} battles)", vd.lastBattleTime.ToUnixDateTime(), vi.vname, vd.tankdata_battlesCount));
ExecuteNonQuery(String.Format("INSERT OR REPLACE INTO VehicleStat VALUES ({0}, {1}, {2}, {3}, {4}, {5})",
Q(dossier.playerName),
vd.lastBattleTime,
vd.vid,
Q(vd.TankDataToJson()),
Q(vd.CompanyDataToJson()),
Q(vd.ClanDataToJson())));
}
}
public bool Supprimer(int voyageId)
{
var voyageData = new VoyageData();
var dossierData = new DossierData();
var voyage = voyageData.GetById(voyageId);
if (dossierData.GetList().Where(x => x.VoyageId == voyageId).Count() > 0)
{
return(false);
}
else
{
return(voyageData.Effacer(voyage));
}
}
public DossierReservation Cloturer(int dossierReservationId)
{
var dossierReservation = new DossierData().GetById(dossierReservationId);
if (dossierReservation != null &&
dossierReservation.EtatDossierReservation == EtatDossierReservation.Accepte &&
DateTime.Now <= new VoyageData().GetById(dossierReservation.VoyageId).DateAller)
{
dossierReservation.EtatDossierReservation = EtatDossierReservation.Clos;
new DossierData().Update(dossierReservation);
new CarteBancaireService().PayerAgence(dossierReservation.PrixParPersonne * 0.9m);
}
return(dossierReservation);
}
public DossierReservation ValiderSolvabilite(int dossierReservationId)
{
var dossierReservation = new DossierData().GetById(dossierReservationId);
if (dossierReservation != null &&
dossierReservation.EtatDossierReservation == EtatDossierReservation.EnAttente)
{
var carteBancaireServie = new CarteBancaireService();
if (carteBancaireServie.ValiderSolvabilite(dossierReservation.NumeroCarteBancaire,
dossierReservation.PrixTotal))
{
dossierReservation.EtatDossierReservation = EtatDossierReservation.EnCours;
new DossierData().Update(dossierReservation);
}
}
return(dossierReservation);
}
public DossierReservation Accepter(int dossierReservationId)
{
var dossierReservation = new DossierData().GetById(dossierReservationId);
if (dossierReservation != null &&
dossierReservation.EtatDossierReservation == EtatDossierReservation.EnCours)
{
var voyage = new VoyageData().GetById(dossierReservation.VoyageId);
if (voyage.PlacesDisponibles >= dossierReservation.Participants.Count)
{
dossierReservation.EtatDossierReservation = EtatDossierReservation.Accepte;
new DossierData().Update(dossierReservation);
new VoyageService().Reserver(voyage, dossierReservation.Participants.Count);
}
else
{
dossierReservation.EtatDossierReservation = EtatDossierReservation.Refuse;
dossierReservation.RaisonAnnulationDossier = RaisonAnnulationDossier.PlacesInsuffisantes;
new DossierData().Update(dossierReservation);
}
}
return(dossierReservation);
}
/// <summary>
/// Checks if this dossier contains the detail with the id specified by <paramref name="id"/>.
/// </summary>
/// <param name="dossierData"></param>
/// <param name="id">The id of the detail to check for existance.</param>
/// <returns></returns>
public static bool HasDetail(this DossierData dossierData, int id)
{
return(dossierData.Details.Count(d => d.Id == id) > 0);
}
/// <summary>
/// Checks if this dossier contains the detail as specified in <paramref name="dossierDetailData"/>.
/// </summary>
/// <param name="dossierData"></param>
/// <param name="dossierDetailData">The detail to check for existance.</param>
/// <returns></returns>
public static bool HasDetail(this DossierData dossierData, DossierDetailData dossierDetailData)
{
return(dossierData.HasDetail(dossierDetailData.Id));
}
/// <summary>
/// Checks if this user has the dossier as specified by <paramref name="dossier"/>.
/// </summary>
/// <param name="userData"></param>
/// <param name="dossier">The dossier to check for existance.</param>
/// <returns></returns>
public static bool HasDossier(this UserData userData, DossierData dossier)
{
return(userData.HasDossier(dossier.Id));
}
private DossierData ParseDossierRawData(string filename, object raw)
{
try
{
DossierData dossier = new DossierData();
dossier.dossierVersion = (int)((raw as object[])[0]);
//if (dossier.dossierVersion != 16)
// throw new Exception("Unsupported dossier cache version: " + dossier.dossierVersion + "\n" + filename);
string[] base32name = Encoding.ASCII.GetString(Utils.FromBase32String(Path.GetFileNameWithoutExtension(filename))).Split(new char[] { ';' }, 2);
dossier.server = base32name[0];
dossier.playerName = base32name[1];
Hashtable vehicleitems = (raw as object[])[1] as Hashtable;
foreach (DictionaryEntry item in vehicleitems)
{
DossierVehicleData vd = new DossierVehicleData();
vd.vid = (int)((item.Key as object[])[1]) & 0xFFFFF0;
byte[] data = (item.Value as object[])[1] as byte[];
if (data == null || data.Length == 0)
{
continue;
}
byte vehicleVersion = data[0];
switch (vehicleVersion)
{
case 20:
vd.AppendStruct(Utils.ReadStruct <VehicleData_20>(data));
break;
case 22:
vd.AppendStruct(Utils.ReadStruct <VehicleData_22>(data));
break;
case 24:
vd.AppendStruct(Utils.ReadStruct <VehicleData_24>(data));
break;
case 26:
vd.AppendStruct(Utils.ReadStruct <VehicleData_26>(data));
break;
case 27:
vd.AppendStruct(Utils.ReadStruct <VehicleData_27>(data));
break;
case 28:
vd.AppendStruct(Utils.ReadStruct <VehicleData_28>(data));
break;
default:
throw new Exception("Unsupported dossier cache vehicle version: " + vehicleVersion);
}
if (dossier.vehicles == null)
{
dossier.vehicles = new List <DossierVehicleData>();
}
dossier.vehicles.Add(vd);
}
return(dossier);
}
catch (Exception ex)
{
throw new Exception("", ex);
}
}
/// <summary>
/// Checks if this dossier contains the note identified by <paramref name="id"/>.
/// </summary>
/// <param name="dossierData"></param>
/// <param name="id">The id of the note to check for existance.</param>
/// <returns></returns>
public static bool HasNote(this DossierData dossierData, int id)
{
return(dossierData.Notes.Count(n => n.Id == id) > 0);
}
/// <summary>
/// Checks if the dossier contains the note specified by <paramref name="noteData"/>.
/// </summary>
/// <param name="dossierData"></param>
/// <param name="noteData">The note to check for existance.</param>
/// <returns></returns>
public static bool HasNote(this DossierData dossierData, NoteData noteData)
{
return(dossierData.HasNote(noteData.Id));
}
/// <summary>
/// Gets the detail identified by <paramref name="id"/>.
/// </summary>
/// <param name="dossierData"></param>
/// <param name="id">The id of the detail to retrieve.</param>
/// <returns></returns>
public static DossierDetailData GetDetail(this DossierData dossierData, int id)
{
return(dossierData.Details.FirstOrDefault(d => d.Id == id));
}
/// <summary>
/// Gets the note identified by <paramref name="id"/>.
/// </summary>
/// <param name="dossierData"></param>
/// <param name="id">The id of the note to retrieve.</param>
/// <returns></returns>
public static NoteData GetNote(this DossierData dossierData, int id)
{
return(dossierData.Notes.FirstOrDefault(n => n.Id == id));
}
