public IActionResult Calculate(string sparte, [FromBody] Angebot model)
{
if (sparte.ToLower() != "kraftfahrt")
{
return(BadRequest("sparte is invalid"));
}
var result = new List <object>();
var errorCount = Math.Floor(new Random().NextDouble() * 6) + 1;
var randomPropertyNames = new List <string>();
for (var i = 0; i < errorCount; i++)
{
var randomPropertyName = GetRandomPropertyName(model);
if (randomPropertyNames.IndexOf(randomPropertyName) > -1)
{
continue;
}
randomPropertyNames.Add(randomPropertyName);
result.Add(CreateError(randomPropertyName));
}
return(BadRequest(result));
}
public Tuple <bool, string> IstAngebotFehlerhaft(Angebot angebot)
{
//Prüfe Titel
if (string.IsNullOrEmpty(angebot.Ueberschrift) || angebot.Ueberschrift.Length == 0)
{
return(new Tuple <bool, string>(true, "Bitte gib deinem Angebot einen Titel."));
}
if (angebot.Ueberschrift.Length > 200)
{
return(new Tuple <bool, string>(true, "Dein Titel darf nicht länger als 200 Zeichen sein."));
}
//Prüfe Beschreibung
char[] delimiters = new char[] { ' ', '\r', '\n' };
if (string.IsNullOrEmpty(angebot.Beschreibung) || angebot.Beschreibung.Split(delimiters, StringSplitOptions.RemoveEmptyEntries).Length < 5)
{
return(new Tuple <bool, string>(true, "Bitte gib deinem Angebot eine aussagekräftige Beschreibung."));
}
//Prüfe Kategorien
if (angebot.Kategorien.Count == 0 || angebot.Kategorien.Count > 5)
{
return(new Tuple <bool, string>(true, "Bitte dein Angebot in mindestens eine und maximal fünf Kategorien einordnen."));
}
return(new Tuple <bool, string>(false, ""));
}
public AngebotDetail()
{
InitializeComponent();
this.a = new Angebot();
this.created = true;
binder = new DataBinding.Binder();
}
public async Task <bool> DeleteAngebotAsync(Angebot angebot)
{
await InitWriteConnectionAsync();
try
{
List <string> prefixes = new List <string>();
prefixes.Add("Angebote/" + angebot.AnbieterId + "/");
prefixes.Add("Fotos/" + angebot.AnbieterId + "/");
prefixes.Add("Nachrichten/" + angebot.AnbieterId + "/");
foreach (var prefix in prefixes)
{
var angebotObjekte = await _writeConnection.ObjectService.ListObjectsAsync(_writeConnection.Bucket, new ListObjectsOptions()
{
Recursive = true, Prefix = prefix
});
foreach (var obj in angebotObjekte.Items.Where(i => !i.IsPrefix && i.Key.Contains(angebot.Id)))
{
await _writeConnection.ObjectService.DeleteObjectAsync(_writeConnection.Bucket, obj.Key);
}
}
}
catch
{
return(false);
}
return(true);
}
public EmailListView(Angebot angebot)
{
InitializeComponent();
this.myAngebot = angebot;
this.InitializeData();
}
private async Task DoPollingAsync(Angebot angebot, CancellationToken token)
{
List <ChatNachricht> nachrichten = new List <ChatNachricht>();
while (!token.IsCancellationRequested)
{
getNachrichtenMutex.WaitOne();
try
{
var nachrichtenNeu = await _chatService.GetNachrichtenAsync(angebot, true);
if (nachrichtenNeu.Count() > 0)
{
foreach (var nachricht in nachrichtenNeu)
{
if (nachrichten.Where(n => n.Id == nachricht.Id).Count() == 0)
{
nachrichten.Add(nachricht);
NachrichtErhalten?.Invoke(angebot, nachricht);
}
}
}
}
catch
{
}
finally
{
getNachrichtenMutex.Release(1);
}
await Task.Delay(2000);
}
}
void BindTo()
{
lv_projekte.Items.Clear();
projekte = new List<string>();
double stundensatz, stdsatzges = 0;
int anz = 0;
projekte.Add("ID:");
projekte.Add("Projektname:");
projekte.Add("Projektdauer:");
projekte.Add("Projektkosten:");
projekte.Add("Stundensatz:");
foreach (var tmp in BL.getProjekte())
{
ListViewItem i = lv_projekte.Items.Add(tmp.Projektid.ToString());
i.Tag = tmp;
Angebot a = new Angebot();
a = BL.getAngebot(tmp.Projektid);
i.SubItems.Add(tmp.Name);
i.SubItems.Add(a.Dauer.ToString());
i.SubItems.Add(a.Summe.ToString("#0.00"));
stundensatz = a.Summe/a.Dauer;
i.SubItems.Add(stundensatz.ToString("#0.00"));
projekte.Add(tmp.Projektid.ToString());
projekte.Add(tmp.Name);
projekte.Add(a.Dauer.ToString());
projekte.Add(a.Summe.ToString("#0.00"));
projekte.Add(stundensatz.ToString("#0.00"));
anz++;
stdsatzges+=stundensatz;
}
DataBinding.Binder binder = new DataBinding.Binder();
stdsatzges = stdsatzges /anz;
binder.BindTo_TextBox(tbstdsatz, stdsatzges.ToString("#0.00"));
}
public async Task <bool> IstAngebotAktivAsync(Angebot angebot)
{
await InitReadConnectionAsync();
var angebotObject = await _readConnection.ObjectService.GetObjectAsync(_readConnection.Bucket, "Angebote/" + angebot.AnbieterId + "/" + angebot.Id);
return(angebotObject.CustomMetaData.Entries.Where(m => m.Key == ANGEBOTSSTAUS && m.Value == ANGEBOT_INAKTIV).Count() == 0);
}
private async Task InitAsync()
{
foreach (var chatInfo in _chatService.GetChatListe())
{
Angebot angebot = await _angebotService.LoadAngebotAsync(chatInfo.AnbieterID + "/" + chatInfo.AngebotID, DateTime.MinValue);
Chats.Add(new ChatViewModel(chatInfo, Factory.GetChatPollingService(), Factory.GetChatService(), Factory.GetLoginService(), Factory.GetChatBufferService(), Factory.GetProfilService(), angebot));
}
}
private async void _chatController_NewChatOpened(ChatInfo newChat)
{
await ChatViewModel._coreDispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
Angebot angebot = await _angebotService.LoadAngebotAsync(newChat.AnbieterID + "/" + newChat.AngebotID, DateTime.MinValue);
Chats.Add(new ChatViewModel(newChat, Factory.GetChatPollingService(), Factory.GetChatService(), Factory.GetLoginService(), Factory.GetChatBufferService(), Factory.GetProfilService(), angebot));
});
}
public void StartPolling(Angebot angebot)
{
CancellationTokenSource source = new CancellationTokenSource();
if (!_pollingTasks.ContainsKey(angebot))
{
Task pollingTask = Task.Factory.StartNew(() => DoPollingAsync(angebot, source.Token), source.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
_pollingTasks.Add(angebot, source);
}
}
public IActionResult Post([FromBody] Angebot model)
{
//if (model == null)
// return BadRequest("Body should not be empty");
//if (model.PartnerId < 1)
// return BadRequest("partnerId is not set");
//_angebotRepository.Create(model);
return(Created($"/angebot/{model.AngebotId}", model));
}
public List <ChatNachricht> GetNachrichten(Angebot angebot)
{
List <ChatNachricht> nachrichten = new List <ChatNachricht>();
var bufferedEntry = _buffer.Where(b => b.AngebotID == angebot.Id).FirstOrDefault();
if (bufferedEntry != null)
{
nachrichten.AddRange(bufferedEntry.Nachrichten);
}
return(nachrichten);
}
public static Offer ToOffer(this Angebot x)
{
return(new Offer
{
Id = x.AngebotId,
Agency = x.Agentur,
Branch = x.Sparte,
Claims = x.Schaeden,
Expire = x.Ablauf,
Fee = x.BeitragZent,
FormattedFee = x.BeitragZent.ToString("C"),
Icon = Branch.Branches.FirstOrDefault(b => b.Label == x.Sparte)?.Icon,
Incident = x.Versichertist,
PaymentInterval = x.Zahlungsweise,
Role = x.Rolle,
OfferUri = $"/partners/{x.PartnerId}/offers/{x.AngebotId}",
OfferCopyUri = $"/partners/{x.PartnerId}/offers/{x.AngebotId}/copy",
OfferEditUri = $"/partners/{x.PartnerId}/offers/{x.AngebotId}/edit",
VehicleData = new VehicleData
{
VehicleType = x.Fahrzeugdaten.Fahrzeugart,
LicensePlate = x.Fahrzeugdaten.Kennzeichen,
ManufacturerNo = x.Fahrzeugdaten.Hsn,
TypeKey = x.Fahrzeugdaten.Typschl,
RegistrationDate = x.Fahrzeugdaten.Erstzulassung,
IdentificationNumber = x.Fahrzeugdaten.Fahrgestell,
Horsepower = x.Fahrzeugdaten.FahrzeugstaerkePS,
ChangeableEngine = x.Fahrzeugdaten.Austauschmotor ? "Ja" : "Nein",
LicensePlateType = x.Fahrzeugdaten.Kennzeichenart,
ChangeableLicensePlate = x.Fahrzeugdaten.Wechselkennzeichen ? "Ja" : "Nein"
},
Usage =
{
AnyDriver = x.Nutzung.BeliebigeFahrer,
NightlyPound = x.Nutzung.NachtAbstellplatz,
DrivingPerformance = x.Nutzung.FahrleistungKm,
Mileage = x.Nutzung.Kilometerstand,
DifferentVehicleOwner = x.Nutzung.AbweichenderFahrzeughalter ? "Ja" : "Nein",
usage = x.Nutzung.AreaOfUsage,
OwnerOccupiedHome = x.Nutzung.SelbstGenEigentum ? "Ja" : "Nein",
HomeOwnershipType = x.Nutzung.Wohneigentumart
},
InsuranceCover =
{
LiabilityDiscount = x.VersSchutz.HaftpflichSFR,
ComprehensiveCoverDiscount = x.VersSchutz.VolkaskoSFR,
WageGroup = x.VersSchutz.Tarifgruppe,
BasicAgreement = x.VersSchutz.Rahmenvertrag,
Start = x.VersSchutz.VersBeginn,
PaymentMethod = x.VersSchutz.Zahlungsweise
}
});
}
public void EndPolling(Angebot angebot)
{
if (_pollingTasks.ContainsKey(angebot))
{
var pollingTask = _pollingTasks[angebot];
if (pollingTask != null)
{
pollingTask.Cancel();
}
_pollingTasks.Remove(angebot);
}
}
void DeleteAngebot(Angebot a)
{
try
{
BL.deleteAngebot(a);
}
catch (BLException ex)
{
MessageBox.Show(ex.Message, a.Titel, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
BindTo();
}
public void BufferNachricht(Angebot angebot, ChatNachricht nachricht, string nachrichtenAccess, bool isNew)
{
ChatInfo newChat = null;
string gegenseiteAnbieterID;
if (_loginService.AnbieterId == nachricht.SenderAnbieterID)
{
gegenseiteAnbieterID = nachricht.EmpfaengerAnbieterID;
}
else
{
gegenseiteAnbieterID = nachricht.SenderAnbieterID;
}
var bufferedEntry = _buffer.Where(b => b.AngebotID == angebot.Id && b.GegenseiteAnbieterID == gegenseiteAnbieterID).FirstOrDefault();
if (bufferedEntry != null)
{
if (string.IsNullOrEmpty(bufferedEntry.NachrichtenAccess) && !string.IsNullOrEmpty(nachrichtenAccess))
{
bufferedEntry.NachrichtenAccess = nachrichtenAccess;
}
if (bufferedEntry.Nachrichten.Where(n => n.Id == nachricht.Id).Count() == 0)
{
bufferedEntry.Nachrichten.Add(nachricht);
}
if (isNew)
{
bufferedEntry.Ungelesen = true;
}
}
else
{
newChat = new ChatInfo();
newChat.AngebotID = angebot.Id;
newChat.AnbieterID = angebot.AnbieterId;
newChat.NachrichtenAccess = nachrichtenAccess;
newChat.Nachrichten.Add(nachricht);
newChat.GegenseiteAnbieterID = gegenseiteAnbieterID;
newChat.Ungelesen = true;
_buffer.Add(newChat);
}
PersistBuffer();
if (newChat != null)
{
NewChatCreated?.Invoke(newChat);
}
}
public ReservierungErstellenDialog(IReservierungService reservierungService, IChatService chatService, Angebot angebot, ChatInfo chatInfo)
{
this.InitializeComponent();
_reservierungService = reservierungService;
_chatService = chatService;
_angebot = angebot;
_chatInfo = chatInfo;
_vm = new ReservierungViewModel();
_vm.Reservierung.AngebotID = angebot.Id;
_vm.Reservierung.AusleiherID = _chatInfo.GegenseiteAnbieterID;
_vm.Reservierung.AnbieterID = angebot.AnbieterId;
}
public SortableBindingList <AngebotsDetail> GetAngebotsDetails(Angebot angebot)
{
var list = new SortableBindingList <AngebotsDetail>();
var dRows = DataManager.SalesDataService.GetAngebotSagePositionRows(angebot.Nummer);
foreach (var dRow in dRows)
{
var detail = new AngebotsDetail(dRow);
if (detail != null && detail.Typ == "Artikel")
{
list.Add(detail);
}
}
return(list.Sort("Sequence"));
}
void DgvAngebote_RowEnter(object sender, DataGridViewCellEventArgs e)
{
this.SelectedAngebot = dgvAngebote.Rows[e.RowIndex].DataBoundItem as Angebot;
if (this.SelectedAngebot != null)
{
this.dgvDetails.DataSource = Model.ModelManager.SalesService.GetAngebotsDetails(this.SelectedAngebot);
//var sb = new StringBuilder();
//var criteria = string.Format("O{0}", this.mySelectedAngebot.Nummer);
//foreach (var mail in Model.ModelManager.DavidService.GetMailItems(criteria))
//{
// sb.AppendLine(mail.Betreff);
//}
//MessageBox.Show(sb.ToString());
}
}
public AngebotViewModel(Angebot angebot)
{
Verfuegbarkeit = Verfuegbarkeit.Unbekannt;
VerfuegbarkeitsDetails = "";
VerfuegbarkeitsAmpel = new SolidColorBrush(Colors.Black);
_thumbnailHelper = Factory.GetThumbnailHelper();
_profilService = Factory.GetProfilService();
Barrel.ApplicationId = "nutzmich_monkeycache";
SetIsNotLoading();
Angebot = angebot;
Fotos = new ObservableCollection <AttachmentImageViewModel>();
Reservierungen = new ObservableCollection <ReservierungsZeitraumViewModel>();
}
public async Task <List <ChatNachricht> > GetNachrichtenAsync(Angebot angebot, bool onlyNewOnes)
{
await InitReadConnectionAsync();
List <ChatNachricht> neueNachrichten = new List <ChatNachricht>();
try
{
var nachrichtenItems = await _readConnection.ObjectService.ListObjectsAsync(_readConnection.Bucket, new ListObjectsOptions()
{
Prefix = "Nachrichten/" + _loginService.AnbieterId + "/" + angebot.Id + "/", Recursive = true
});
foreach (var nachrichtItem in nachrichtenItems.Items)
{
if (nachrichtItem.IsPrefix || nachrichtItem.Key.Contains("Token"))
{
continue;
}
var nachricht = await LoadNachrichtAsync(nachrichtItem.Key);
if (nachricht != null)
{
if (!string.IsNullOrEmpty(nachricht.TechnischerNachrichtenTyp) && nachricht.TechnischerNachrichtenTyp == Reservierung.TECHNISCHER_NACHRICHTENTYP)
{
await _reservierungService.ReservierungBestaetigenAsync(Newtonsoft.Json.JsonConvert.DeserializeObject <Reservierung>(nachricht.Nachricht));
}
_chatBufferService.BufferNachricht(angebot, nachricht, null, true);
neueNachrichten.Add(nachricht);
}
}
}catch
{
}
if (onlyNewOnes)
{
return(neueNachrichten);
}
else
{
return(_chatBufferService.GetNachrichten(angebot).OrderByDescending(n => n.SendeDatum).ToList());
}
}
public async Task <List <Stream> > GetAngebotImagesAsync(Angebot angebot)
{
await InitReadConnectionAsync();
List <Stream> result = new List <Stream>();
var images = await _readConnection.ObjectService.ListObjectsAsync(_readConnection.Bucket, new ListObjectsOptions()
{
Prefix = "Fotos/" + angebot.AnbieterId + "/" + angebot.Id + "/", System = true, Recursive = true
});
foreach (var image in images.Items.Where(i => !i.IsPrefix).OrderBy(i => i.Key))
{
result.Add(new DownloadStream(_readConnection.Bucket, (int)image.SystemMetaData.ContentLength, image.Key));
}
return(result);
}
private async void _chatPollingService_NachrichtErhalten(Angebot angebot, ChatNachricht nachricht)
{
if (angebot.Id != AngebotViewModel.Angebot.Id || nachricht.SenderAnbieterID == _loginService.AnbieterId)
{
return;
}
await _coreDispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var neueNachricht = new ChatNachrichtViewModel(nachricht)
{
IchBinEmpfaenger = true
};
Nachrichten.Add(neueNachricht);
ScrollToChatNachricht?.Invoke(neueNachricht);
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Ungelesen)));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(NeuesteNachricht)));
});
}
public async Task SendNachrichtAsync(Angebot angebot, ChatNachricht nachricht, string accessGrant, bool includeForeignAccess = false)
{
string accessGrantToUse;
//Idee: wenn accessGrant leer, dann aus foreign nachlesen
if (string.IsNullOrEmpty(accessGrant))
{
await InitReadConnectionAsync();
var accessDownload = await _readConnection.ObjectService.DownloadObjectAsync(_readConnection.Bucket, "Nachrichten/" + nachricht.SenderAnbieterID + "/" + nachricht.AngebotID + "/" + nachricht.EmpfaengerAnbieterID + "/Token", new DownloadOptions(), false);
await accessDownload.StartDownloadAsync();
accessGrantToUse = Encoding.UTF8.GetString(accessDownload.DownloadedBytes);
}
else
{
accessGrantToUse = accessGrant;
}
var foreignConnection = await InitForeignConnectionAsync(accessGrantToUse);
if (includeForeignAccess)
{
var token = _identityService.CreatePartialWriteAccess("Nachrichten/" + nachricht.SenderAnbieterID + "/" + nachricht.AngebotID + "/" + nachricht.EmpfaengerAnbieterID + "/");
var foreignAccessUpload = await foreignConnection.ObjectService.UploadObjectAsync(foreignConnection.Bucket, "Nachrichten/" + nachricht.EmpfaengerAnbieterID + "/" + nachricht.AngebotID + "/" + nachricht.SenderAnbieterID + "/Token", new UploadOptions(), Encoding.UTF8.GetBytes(token), false);
await foreignAccessUpload.StartUploadAsync();
}
var nachrichtJson = Newtonsoft.Json.JsonConvert.SerializeObject(nachricht);
var nachrichtUpload = await foreignConnection.ObjectService.UploadObjectAsync(foreignConnection.Bucket, "Nachrichten/" + nachricht.EmpfaengerAnbieterID + "/" + nachricht.AngebotID + "/" + nachricht.SenderAnbieterID + "/" + nachricht.Id, new UploadOptions()
{
Expires = DateTime.Now.AddDays(7)
}, Encoding.UTF8.GetBytes(nachrichtJson), false);
await nachrichtUpload.StartUploadAsync();
_chatBufferService.BufferNachricht(angebot, nachricht, accessGrantToUse, false);
}
public ChatViewModel(ChatInfo chatInfo, IChatPollingService chatPollingService, IChatService chatService, ILoginService loginService, IChatBufferService chatBufferService, IProfilService profilService, Angebot angebot)
{
_chatPollingService = chatPollingService;
_chatPollingService.NachrichtErhalten += _chatPollingService_NachrichtErhalten;
_chatService = chatService;
_loginService = loginService;
_chatBufferService = chatBufferService;
_profilService = profilService;
Nachrichten = new ObservableCollection <ChatNachrichtViewModel>(chatInfo.Nachrichten.Select(c => new ChatNachrichtViewModel(c)
{
IchBinEmpfaenger = _loginService.AnbieterId == c.EmpfaengerAnbieterID, IchWarSender = _loginService.AnbieterId == c.SenderAnbieterID
}));
AngebotViewModel = new AngebotViewModel(angebot);
_chatPollingService.StartPolling(angebot);
_chatInfo = chatInfo;
InitGegenseiteAsync();
}
public void Create(Angebot angebot)
{
angebot.AngebotId = _data.Count + 1;
angebot.AngebotURI = $"{_options.ServerUrl}/angebot/{angebot.AngebotId}";
_data.Add(angebot);
}
public void CreateAngebot(Angebot angebot)
{
throw new NotImplementedException();
}
public async Task <bool> SaveAngebotAsync(Angebot angebot, List <AttachmentImage> images, bool angebotAktiv = true)
{
await InitWriteConnectionAsync();
angebot.EingestelltAm = DateTime.Now;
angebot.AnbieterId = _loginService.AnbieterId;
if (images.Count > 0)
{
angebot.ThumbnailBase64 = await _thumbnailHelper.ThumbnailToBase64Async(images.First());
}
if (string.IsNullOrEmpty(angebot.NachrichtenAccess))
{
angebot.NachrichtenAccess = _identityService.CreatePartialWriteAccess("Nachrichten/" + _loginService.AnbieterId + "/" + angebot.Id + "/");
}
var angebotJSON = Newtonsoft.Json.JsonConvert.SerializeObject(angebot);
var angebotJSONbytes = Encoding.UTF8.GetBytes(angebotJSON);
string key = "Angebote/" + _loginService.AnbieterId + "/" + angebot.Id.ToString();
var customMeta = new CustomMetadata();
if (angebotAktiv)
{
customMeta.Entries.Add(new CustomMetadataEntry()
{
Key = ANGEBOTSSTAUS, Value = ANGEBOT_AKTIV
});
}
else
{
customMeta.Entries.Add(new CustomMetadataEntry()
{
Key = ANGEBOTSSTAUS, Value = ANGEBOT_INAKTIV
});
}
customMeta.Entries.Add(new CustomMetadataEntry()
{
Key = ANGEBOT_VERSION_VOM, Value = DateTime.Now.ToString()
});
var angebotUpload = await _writeConnection.ObjectService.UploadObjectAsync(_writeConnection.Bucket, key, new UploadOptions(), angebotJSONbytes, customMeta, false);
await angebotUpload.StartUploadAsync();
int count = 1;
foreach (var image in images)
{
string fotoKey = "Fotos/" + _loginService.AnbieterId + "/" + angebot.Id.ToString() + "/" + count;
//Prüfen, ob das hochzuladende Bild schon existiert
try
{
var existingObject = await _writeConnection.ObjectService.GetObjectAsync(_writeConnection.Bucket, fotoKey);
//Es existiert - wenn die Dateigröße gleich ist, dann nicht nochmal hochladen
if (existingObject.SystemMetaData.ContentLength == image.Stream.Length)
{
count++;
continue;
}
}
catch { } //Dann existiert es noch nicht
image.Stream.Position = 0;
var queue = new uplink.NET.Services.UploadQueueService();
await queue.AddObjectToUploadQueue(_writeConnection.Bucket.Name, fotoKey, _identityService.GetIdentityWriteAccess().Serialize(), image.Stream.ToMemoryStream().ToArray(), angebot.Ueberschrift + " - Bild " + count.ToString());
queue.ProcessQueueInBackground();
//var imageUpload = await _writeConnection.ObjectService.UploadObjectAsync(_writeConnection.Bucket, fotoKey, new UploadOptions(), image.Stream, false);
//await imageUpload.StartUploadAsync();
count++;
image.Stream.Position = 0;
Barrel.Current.Add <byte[]>(fotoKey, image.Stream.ToMemoryStream().ToArray(), TimeSpan.FromDays(365));
}
while (true)
{
string fotoKey = "Fotos/" + _loginService.AnbieterId + "/" + angebot.Id.ToString() + "/" + count;
try
{
var existingObject = await _writeConnection.ObjectService.GetObjectAsync(_writeConnection.Bucket, fotoKey);
//Es existiert - lösche es - alle gewünschten Bilder sind schon oben
await _writeConnection.ObjectService.DeleteObjectAsync(_writeConnection.Bucket, fotoKey);
count++;
}
catch
{
//Es gibt nicht mehr Bilder, alles bereinigt
break;
}
}
Barrel.Current.Add <Angebot>("angebot_" + key.Replace("Angebote/", ""), angebot, TimeSpan.FromDays(180));
return(angebotUpload.Completed);
}
void EditAngebot(Angebot a)
{
Dialogs.AngebotDetail tmp = new Dialogs.AngebotDetail(a);
tmp.ShowDialog();
BindTo();
}
public AngebotDetail(Angebot a)
{
InitializeComponent();
this.a = a;
binder = new DataBinding.Binder();
}
