Beiträge von jklein

leider geht er da nicht rein, wenn ich mich mit stepinto durchdebugge, ich denke das ist eine zuweisung, wenn ja wo kan ich die methode finden ?

die variable m_note is angeblich noting,dabei hat sie einen inhalt wenn man unter variablen hineinschaut

ja, aber das feld hat doch ein datumswert in der blau - hinterlegten zeile wirft er den fehler

ja klar geht das, hatte tomaten auf den augen. konnte den fehler lokalisieren, nur leider finde ich das feld nicht was fehlt.

Domino.NotesDatabase notesDatabase = null;
Domino.NotesSession notesSession = null;

// SerienTermin erstellen
Domino.NotesDocument parentNotesDocument = null;
Domino.NotesDocument childNotesDocument = null;

string iconNumber = "@TextToNumber(" + ((char)(34)).ToString() + "160" + ((char)(34)).ToString() + ")";

string sequenceNumber = "@TextToNumber(" + ((char)(34)).ToString() + "1" + ((char)(34)).ToString() + ")";

string startDateTime = "@TextToTime(" + ((char)(34)).ToString() + "25.05.2009 08:45:00" + ((char)(34)).ToString() + ")"
+ ":@TextToTime(" + ((char)(34)).ToString() + "26.05.2009 08:45:00" + ((char)(34)).ToString() + ")"
+ ":@TextToTime(" + ((char)(34)).ToString() + "27.05.2009 08:45:00" + ((char)(34)).ToString() + ")"
+ ":@TextToTime(" + ((char)(34)).ToString() + "28.05.2009 08:45:00" + ((char)(34)).ToString() + ")"
+ ":@TextToTime(" + ((char)(34)).ToString() + "29.05.2009 08:45:00" + ((char)(34)).ToString() + ")";

string startDate = "@TextToTime(" + ((char)(34)).ToString() + "25.05.2009 08:45:00" + ((char)(34)).ToString() + ")";

string endDateTime = "@TextToTime(" + ((char)(34)).ToString() + "25.05.2009 09:45:00" + ((char)(34)).ToString() + ")"
+ ":@TextToTime(" + ((char)(34)).ToString() + "26.05.2009 09:45:00" + ((char)(34)).ToString() + ")"
+ ":@TextToTime(" + ((char)(34)).ToString() + "27.05.2009 09:45:00" + ((char)(34)).ToString() + ")"
+ ":@TextToTime(" + ((char)(34)).ToString() + "28.05.2009 09:45:00" + ((char)(34)).ToString() + ")"
+ ":@TextToTime(" + ((char)(34)).ToString() + "29.05.2009 09:45:00" + ((char)(34)).ToString() + ")";

string endDate = "@TextToTime(" + ((char)(34)).ToString() + "25.05.2009 09:45:00" + ((char)(34)).ToString() + ")";
try
{
// Session initalisieren
notesSession = new Domino.NotesSession();
notesSession.Initialize("geheim");

// Datenbank holen
notesDatabase = notesSession.GetDatabase("DominoDevelopServer/BDL", "mail\\administ.nsf", false);

parentNotesDocument = notesDatabase.CreateDocument();
childNotesDocument = notesDatabase.CreateDocument();

// Repeat - Felder
//parentNotesDocument.ReplaceItemValue("RepeatAdjust","");
parentNotesDocument.ReplaceItemValue("RepeatEndDates", notesSession.Evaluate(endDateTime,parentNotesDocument));
//parentNotesDocument.ReplaceItemValue("RepeatCustom", "");
// List of Current Dates ...
parentNotesDocument.ReplaceItemValue("RepeatDates", notesSession.Evaluate(startDateTime,parentNotesDocument));
parentNotesDocument.ReplaceItemValue("RepeatForJunit", "D");
parentNotesDocument.ReplaceItemValue("RepeatFromEnd", "");
parentNotesDocument.ReplaceItemValue("RepeatHow", "F");
parentNotesDocument.ReplaceItemValue("RepeatInstanceDate", notesSession.Evaluate(startDateTime, parentNotesDocument));
parentNotesDocument.ReplaceItemValue("RepeatInterval", "1");
parentNotesDocument.ReplaceItemValue("RepeatStartDate", notesSession.Evaluate(startDateTime,parentNotesDocument));
parentNotesDocument.ReplaceItemValue("RepeatUnit", "D");
parentNotesDocument.ReplaceItemValue("RepeatUntil", "");
parentNotesDocument.ReplaceItemValue("RepeatWeekends", "D");

// Appointment - Items
parentNotesDocument.ReplaceItemValue("$CSFlags", "c"); //spez
//parentNotesDocument.ReplaceItemValue("$CSTrack", "");
//parentNotesDocument.ReplaceItemValue("$CSVersion", "");
//parentNotesDocument.ReplaceItemValue("$CSWISL", "");
//parentNotesDocument.ReplaceItemValue("$Ref", "");
//parentNotesDocument.ReplaceItemValue("$Seal", "");
//parentNotesDocument.ReplaceItemValue("$SealData", "");
//parentNotesDocument.ReplaceItemValue("$Signature", "");
//parentNotesDocument.ReplaceItemValue("$WatchedItem", "");
parentNotesDocument.ReplaceItemValue("_ViewIcon", notesSession.Evaluate(iconNumber, parentNotesDocument));
//parentNotesDocument.ReplaceItemValue("_ViewIcon2", "");
parentNotesDocument.ReplaceItemValue("AltChair", "CN=Administrator/O=TEST");
parentNotesDocument.ReplaceItemValue("AppointmentType", "0"); //spez
parentNotesDocument.ReplaceItemValue("ApptUNID", parentNotesDocument.UniversalID);
//parentNotesDocument.ReplaceItemValue("Body", "");
//parentNotesDocument.ReplaceItemValue("Broadcast", "");
//parentNotesDocument.ReplaceItemValue("Categories", "");
parentNotesDocument.ReplaceItemValue("Chair", "CN=Administrator/O=TEST");
parentNotesDocument.ReplaceItemValue("EndDateTime", notesSession.Evaluate(endDate,parentNotesDocument));
parentNotesDocument.ReplaceItemValue("EndTimeZone","Z=-1$DO=1$DL=3 -1 1 10 -1 1$ZX=83$ZN=W. Europe");
//parentNotesDocument.ReplaceItemValue("ExcludeFromView", "");
parentNotesDocument.ReplaceItemValue("Form", "Appointment"); //spez
parentNotesDocument.ReplaceItemValue("From", "CN=Administrator/O=TEST"); //spez
parentNotesDocument.ReplaceItemValue("Location", "Geisenheim");
parentNotesDocument.ReplaceItemValue("Logo", "stdNotesLtr0");
//parentNotesDocument.ReplaceItemValue("NoticeType", "");
//parentNotesDocument.ReplaceItemValue("MeetingType", "1");
//parentNotesDocument.ReplaceItemValue("OptionalAttendess", "");
//parentNotesDocument.ReplaceItemValue("OrgConfidential", "");
parentNotesDocument.ReplaceItemValue("OrgRepeat", "1");
parentNotesDocument.ReplaceItemValue("OrgTable", "1");
//parentNotesDocument.ReplaceItemValue("OriginalEndDate", "");
//parentNotesDocument.ReplaceItemValue("OriginalEndTimeZone", "");
//parentNotesDocument.ReplaceItemValue("OriginalStartDate", "");
//parentNotesDocument.ReplaceItemValue("OriginalStartTimeZone", "");
//parentNotesDocument.ReplaceItemValue("ParentRepeatDates", "");
//parentNotesDocument.ReplaceItemValue("ParentRepeatInstanceDates", "");
//parentNotesDocument.ReplaceItemValue("PreventCounter", "");
//parentNotesDocument.ReplaceItemValue("PreventDelegate", "");
parentNotesDocument.ReplaceItemValue("Repeats", "1");
//parentNotesDocument.ReplaceItemValue("RepeatInstanceDate", "");
//parentNotesDocument.ReplaceItemValue("RequiredAttendees", "");
//parentNotesDocument.ReplaceItemValue("RescheduleEndDateTimes", "");
//parentNotesDocument.ReplaceItemValue("RescheduleInstanceDates", "");
//parentNotesDocument.ReplaceItemValue("RescheduleStartDateTimes", "");
//parentNotesDocument.ReplaceItemValue("RescheduleWhich", "");
parentNotesDocument.ReplaceItemValue("SequenceNum", notesSession.Evaluate(sequenceNumber,parentNotesDocument));
//parentNotesDocument.ReplaceItemValue("StartDate", "");
parentNotesDocument.ReplaceItemValue("StartDateTime", notesSession.Evaluate(startDateTime,childNotesDocument));
parentNotesDocument.ReplaceItemValue("StartTimeZone", "Z=-1$DO=1$DL=3 -1 1 10 -1 1$ZX=83$ZN=W. Europe");
//parentNotesDocument.ReplaceItemValue("StatusUpdate", "");
//parentNotesDocument.ReplaceItemValue("StorageRequriedNames", "");
parentNotesDocument.ReplaceItemValue("Subject", "Serie aus dialogcrm");
//parentNotesDocument.ReplaceItemValue("Topic", "");
//parentNotesDocument.ReplaceItemValue("UpdateSequence", "");

// Notes-Dokument speichern
parentNotesDocument.ComputeWithForm(true, false);
parentNotesDocument.Save(true, false, true);

//Child
// Appointment - Items
childNotesDocument.MakeResponse(parentNotesDocument);
childNotesDocument.ReplaceItemValue("$CSFlags", "i");
//childNotesDocument.ReplaceItemValue("$CSTrack", "");
childNotesDocument.ReplaceItemValue("$CSVersion", "2"); //?
//childNotesDocument.ReplaceItemValue("$CSWISL", "");
//childNotesDocument.ReplaceItemValue("$Ref", ""); // wird angeblich duch Response erstellt
childNotesDocument.ReplaceItemValue("$RefOptions", "1");
childNotesDocument.ReplaceItemValue("$Seal", "");
//childNotesDocument.ReplaceItemValue("$SealData", "");
//childNotesDocument.ReplaceItemValue("$Signature", "");
//childNotesDocument.ReplaceItemValue("$WatchedItem", "");
childNotesDocument.ReplaceItemValue("_ViewIcon", notesSession.Evaluate(iconNumber, parentNotesDocument));
//childNotesDocument.ReplaceItemValue("_ViewIcon2", "");
childNotesDocument.ReplaceItemValue("AltChair", "CN=Administrator/O=TEST");
childNotesDocument.ReplaceItemValue("AppointmentType", "0");
childNotesDocument.ReplaceItemValue("ApptUNID", parentNotesDocument.UniversalID);
childNotesDocument.ReplaceItemValue("Body", "");
//childNotesDocument.ReplaceItemValue("Broadcast", "");
childNotesDocument.ReplaceItemValue("CalendarDateTime", notesSession.Evaluate(startDateTime,childNotesDocument));
//childNotesDocument.ReplaceItemValue("Categories", ""); // is leer
childNotesDocument.ReplaceItemValue("Chair", "CN=Administrator/O=TEST");
childNotesDocument.ReplaceItemValue("EndDateTime", notesSession.Evaluate(endDateTime,childNotesDocument));
childNotesDocument.ReplaceItemValue("EndTimeZone", "Z=-1$DO=1$DL=3 -1 1 10 -1 1$ZX=83$ZN=W. Europe");
//childNotesDocument.ReplaceItemValue("ExcludeFromView", "");
childNotesDocument.ReplaceItemValue("Form", "Appointment");
childNotesDocument.ReplaceItemValue("From", "CN=Administrator/O=TEST");
childNotesDocument.ReplaceItemValue("Location", "Geisenheim");
childNotesDocument.ReplaceItemValue("Logo", "stdNotesLtr0");
childNotesDocument.ReplaceItemValue("MeetingType", "1");
//childNotesDocument.ReplaceItemValue("NoticeType", "");
//childNotesDocument.ReplaceItemValue("OptionalAttendess", "");
childNotesDocument.ReplaceItemValue("OrgConfidential", "");
childNotesDocument.ReplaceItemValue("OrgRepeat", "1");
childNotesDocument.ReplaceItemValue("OrgTable", "C0");
//childNotesDocument.ReplaceItemValue("OriginalEndDate", "");
//childNotesDocument.ReplaceItemValue("OriginalEndTimeZone", "");
//childNotesDocument.ReplaceItemValue("OriginalStartDate", "");
//childNotesDocument.ReplaceItemValue("OriginalStartTimeZone", "");
//childNotesDocument.ReplaceItemValue("ParentRepeatDates", "");
//childNotesDocument.ReplaceItemValue("ParentRepeatInstanceDates", "");
//childNotesDocument.ReplaceItemValue("PreventCounter", "");
//childNotesDocument.ReplaceItemValue("PreventDelegate", "");
//childNotesDocument.ReplaceItemValue("Repeats", "1");
//childNotesDocument.ReplaceItemValue("RepeatInstanceDate", notesSession.Evaluate(startDateTime,childNotesDocument));
//childNotesDocument.ReplaceItemValue("RequiredAttendees", "");
//childNotesDocument.ReplaceItemValue("RescheduleEndDateTimes", "");
//childNotesDocument.ReplaceItemValue("RescheduleInstanceDates", "");
//childNotesDocument.ReplaceItemValue("RescheduleStartDateTimes", "");
//childNotesDocument.ReplaceItemValue("RescheduleWhich", "");
childNotesDocument.ReplaceItemValue("SequenceNum", notesSession.Evaluate(sequenceNumber, parentNotesDocument));
//childNotesDocument.ReplaceItemValue("StartDate", "");
childNotesDocument.ReplaceItemValue("StartDateTime", notesSession.Evaluate(startDateTime,childNotesDocument));
childNotesDocument.ReplaceItemValue("StartTimeZone", "Z=-1$DO=1$DL=3 -1 1 10 -1 1$ZX=83$ZN=W. Europe");
//childNotesDocument.ReplaceItemValue("StatusUpdate", "");
//childNotesDocument.ReplaceItemValue("StorageRequriedNames", "");
childNotesDocument.ReplaceItemValue("Subject", "Serie aus dialogcrm");
//childNotesDocument.ReplaceItemValue("Topic", "");
//childNotesDocument.ReplaceItemValue("UpdateSequence", "");
//childNotesDocument.ReplaceItemValue("tmpOwnerHw",

// Notes-Dokument speichern
childNotesDocument.ComputeWithForm(true, false);
childNotesDocument.Save(true, false, true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}

ok entschuldigung, ich habe halt nur im lotus notes designer das debugging gefunden, und da möchte ich es nicht. ich würde gern im client sehen, warum der fehler auftritt. aber das scheint nicht zu gehen.

unterm designer ist dies ja unter tools .. hab ich überhaupt ne möglichkeit im client?

das habe ich bereits gemacht ....

To disable persistent breakpoints
Click File > Preferences.
Click Basic Notes Client Configuration.
Under Additional Options, click Enable persistent breakpoints in LotusScript debugger.
Click OK.

aber der log wirft nichts aus wenn ich einen appointment öffne etc .. oder gibt es eine seperate logausgabe?

ich würde halt einfach gerne sehen, das item konnte nicht gefunden werden .... also setze ich es .. und mich so voran tasten, ich hab leider nicht die zeit mich richtig in lotus notes einzuarbeiten, auch wenn es interessant ist. die schönheitskorrekturen kann ich danach ja machen. aber erstma muss der prototyp her

in der log.nsf steht leider nur drin, wann ich mich angemeldet und abgemeldet habe ...

ja es fehlen sicherlich noch welche, die auch im buch stehen.

kannst du mir sagen wie ich dies debuggen kann, weil es gibt ja eine mindestmenge an feldern die man braucht und einige die zusatz sind. ich muss ja auch sehen, das ich die termine mit den vorhandenen informationen aus dem gegensystem fuelle, ohne dabei zu viele statische daten im programm zu haben.

wie sehe ich denn, was genau notes stört , wenn notesitem not found kommt. wo ist die debugfunktion?

So jetzt bin ich schon wesentlich weiter, leider gehen nur Reminder keine Termeine. Setze ich den AppointmentTyp auf 0, bekomme ich einen NoItemNotFound error. Bei dem Typ Reminder, erkennt er das Dokument als Serie und ich kann es demtentsprechend auch bearbeiten.

Domino.NotesSession notesSession = null;
Domino.NotesDatabase notesDatabase = null;
Domino.NotesRichTextItem richTextItem = null;

Domino.NotesDocument notesParentDocument = null;
Domino.NotesDocument notesChildDocument = null;

/* PARENT - Dokument erstellen
* - hat kein CalendarDateTime
* - im Feld RepeatInstanceDates Liste von ursprünglichen Datumswerten
* - im Feld RepeatDates Liste der aktuellen Datumswerte
* - uniqueID des Mater-Dokuments = ApptUNID der Kind-Dokumente und des Master - Dokuments
*
* Wichtige Felder
* - RepeatInstanceDates
* - RepeatDates
* - $SCFlags = c
* - _ViewIcon = 160
* - Appointmenttype = 0
* - Repeats = 1
* - SequenceNum = 1
* - ApptUNID auf uniqueID setzen
* - Start und EndDateTime haben nur min(Time)
*/

// ein Notes-Dokument darf nur erstellt werden, wenn folgende Variablen gefuellt sind
if (_syncUser != null && _syncUser != null)
{
// Session initalisieren
notesSession = new Domino.NotesSession();
notesSession.Initialize(Setting.NotesSyncUserPassword);

// Verbindung zur Mail-Datenbank aufbauen
notesDatabase = _syncUser.GetNotesDatabase(notesSession);

// Notes-Dokument erstellen
notesParentDocument = notesDatabase.CreateDocument();
// Sicherheitsabfrage ob Domino-Verbindung und Session steht
if (notesParentDocument != null && notesSession != null && notesDatabase != null)
{
// uniqueID aus neuem Notes-Dokument auslesen
uniqueID = notesParentDocument.UniversalID;

// Notes-Dokument mit Sync-Feldern fuellen
foreach (FieldMapping field in _fieldList)
{
if (field.NotesFieldName.Equals("Body"))
{
richTextItem = notesParentDocument.CreateRichTextItem("Body");
richTextItem.AppendText(field.Value);

// wenn Appo / Task Attachment enthaelt muessen diese angefuegt werden
if (HasAttachments(oraConn))
{
richTextItem = AddAttachments(oraConn, richTextItem);
}
}
else
{
notesParentDocument.ReplaceItemValue(field.NotesFieldName, field.Value);
}
}

// Form-Namen je nach Sync-Typ zuweisen
switch (_syncType)
{
case eSyncType.APPO:
notesParentDocument.ReplaceItemValue("Form", "Appointment");
break;
case eSyncType.TASK:
notesParentDocument.ReplaceItemValue("Form", "Task");
break;
default:
break;
}

// ReplicaID setzen
notesParentDocument.ReplaceItemValue("ApptUNID", uniqueID);

notesDateString = CreateNotesDateTime(GetDateTime(oraConn, eDateType.ENDDATE));
if (!notesDateString.Equals(""))
{
notesParentDocument.ReplaceItemValue("EndDateTime", notesSession.Evaluate(notesDateString, notesParentDocument));
}

notesDateString = CreateNotesDateTime(GetDateTime(oraConn, eDateType.STARTDATE));
if (!notesDateString.Equals(""))
{
notesParentDocument.ReplaceItemValue("StartDateTime", notesSession.Evaluate(notesDateString, notesParentDocument));
}

notesDateString = CreateNotesDateTime(GetDateTime(oraConn, eDateType.ORIGINALDATE));
if (!notesDateString.Equals(""))
{
notesParentDocument.ReplaceItemValue("RepeatInstanceDates", notesSession.Evaluate(notesDateString, notesParentDocument));
}

notesDateString = CreateNotesDateTime(GetDateTime(oraConn, eDateType.CURRENTDATE));
if (!notesDateString.Equals(""))
{
notesParentDocument.ReplaceItemValue("RepeatDates", notesSession.Evaluate(notesDateString, notesParentDocument));
}

notesParentDocument.ReplaceItemValue("$CSFlags", "c");
notesParentDocument.ReplaceItemValue("_ViewIcon", notesSession.Evaluate("@TextToNumber(" + ((char)(34)).ToString() + "160" + ((char)(34)).ToString() + ")", notesParentDocument));
notesParentDocument.ReplaceItemValue("AppointmentType", "4");
notesParentDocument.ReplaceItemValue("Repeats", "4");
notesParentDocument.ReplaceItemValue("SequenceNum", notesSession.Evaluate("@TextToNumber(" + ((char)(34)).ToString() + "1" + ((char)(34)).ToString() + ")", notesParentDocument));
notesParentDocument.RemoveItem("CalendarDateTime");

notesParentDocument.ReplaceItemValue("AltChair", "CN=Administrator/O=HANS");
notesParentDocument.ReplaceItemValue("Chair", "CN=Administrator/O=HANS");
notesParentDocument.ReplaceItemValue("RepeatInterval", "1");
notesParentDocument.ReplaceItemValue("OrgRepeat", "1");
notesParentDocument.ReplaceItemValue("OrgTable", "C0");
notesParentDocument.ReplaceItemValue("MeetingType", "1");

notesParentDocument.ReplaceItemValue("tmpAppointmentType", "Reminder");
notesParentDocument.ReplaceItemValue("tmpAppointmentType1", "Reminder");
notesParentDocument.ReplaceItemValue("tmpOwnerHW", "0");
notesParentDocument.ReplaceItemValue("tmpChair", "CN=Administrator/O=HANS");

replicaID = uniqueID;

// CHILD
try
{

while (oraReader.Read())
{
_refNotesID = Convert.ToInt32(oraReader.GetDecimal(0));
FillFieldMappingList(oraConn);
notesChildDocument = notesDatabase.CreateDocument();

/* Kind-Dokumente erstellen
* - Aufbau: 1) nur ein Kind (es gibt keine Abweichler)
* 2) ein Abweichler in der Mitte
* - Kind mit Daten bis Abweichler
* - Kind (Abweichler)
* - Kind Daten bis Ende
* 3) mehre Abweichler
* - beliebig Kinder
*
* nur Kinder werden in den Alarm-Ordner gesteckt
*
* Wichtige Felder
* - $SCFlafs = i
* - $Ref und ApptUNID auf uniqueID des Parents setzen
* - Start - End - CalendarDateTime habenliste der Daten
* - §RefOptions = 1
* - _ViewIcon = 160
* - Appointmenttype = 0
* - Repeats = 1
* - SequenceNum = 1
*/

// Sicherheitsabfrage ob Domino-Verbindung und Session steht
if (notesChildDocument != null && notesSession != null && notesDatabase != null)
{
notesChildDocument.MakeResponse(notesParentDocument);
// uniqueID aus neuem Notes-Dokument auslesen
uniqueID = notesChildDocument.UniversalID;

// Notes-Dokument mit Sync-Feldern fuellen
foreach (FieldMapping field in _fieldList)
{
if (field.NotesFieldName.Equals("Body"))
{
richTextItem = notesChildDocument.CreateRichTextItem("Body");
richTextItem.AppendText(field.Value);

// wenn Appo / Task Attachment enthaelt muessen diese angefuegt werden
if (HasAttachments(oraConn))
{
richTextItem = AddAttachments(oraConn, richTextItem);
}
}
else
{
notesChildDocument.ReplaceItemValue(field.NotesFieldName, field.Value);
}
}

// Form-Namen je nach Sync-Typ zuweisen
switch (_syncType)
{
case eSyncType.APPO:
notesChildDocument.ReplaceItemValue("Form", "Appointment");
break;
case eSyncType.TASK:
notesChildDocument.ReplaceItemValue("Form", "Task");
break;
default:
break;
}

// ReplicaID setzen
notesChildDocument.ReplaceItemValue("ApptUNID", replicaID);

// Start-, End-, Calendar- und DueDateTime setzen
notesDateString = CreateNotesDateTime(GetDateTime(oraConn, eDateType.CALENDARDATE));
if (!notesDateString.Equals(""))
{
notesChildDocument.ReplaceItemValue("CalendarDateTime", notesSession.Evaluate(notesDateString, notesChildDocument));
}

notesDateString = CreateNotesDateTime(GetDateTime(oraConn, eDateType.DUEDATE));
if (!notesDateString.Equals(""))
{
notesChildDocument.ReplaceItemValue("DueDateTime", notesSession.Evaluate(notesDateString, notesChildDocument));
}

notesDateString = CreateNotesDateTime(GetDateTime(oraConn, eDateType.ENDDATE));
if (!notesDateString.Equals(""))
{
notesChildDocument.ReplaceItemValue("EndDateTime", notesSession.Evaluate(notesDateString, notesChildDocument));
}

notesDateString = CreateNotesDateTime(GetDateTime(oraConn, eDateType.STARTDATE));
if (!notesDateString.Equals(""))
{
notesChildDocument.ReplaceItemValue("StartDateTime", notesSession.Evaluate(notesDateString, notesChildDocument));
}

notesChildDocument.ReplaceItemValue("$CSFlags", "i");
notesChildDocument.ReplaceItemValue("$RefOptions", "1");
notesChildDocument.ReplaceItemValue("$SCFlags", "i");
notesChildDocument.ReplaceItemValue("_ViewIcon", notesSession.Evaluate("@TextToNumber(" + ((char)(34)).ToString() + "160" + ((char)(34)).ToString() + ")", notesParentDocument));
notesChildDocument.ReplaceItemValue("AppointmentType", "4");
notesChildDocument.ReplaceItemValue("Repeats", "1");
notesChildDocument.ReplaceItemValue("SequenceNum", notesSession.Evaluate("@TextToNumber(" + ((char)(34)).ToString() + "1" + ((char)(34)).ToString() + ")", notesParentDocument));
notesChildDocument.ReplaceItemValue("AltChair", "CN=Administrator/O=HANS");
notesChildDocument.ReplaceItemValue("Chair", "CN=Administrator/O=HANS");
notesChildDocument.ReplaceItemValue("RepeatInterval", "1");
notesChildDocument.ReplaceItemValue("OrgRepeat", "1");
notesChildDocument.ReplaceItemValue("OrgTable", "C0");
notesChildDocument.ReplaceItemValue("MeetingType", "1");

// Notes-Dokument speichern
notesChildDocument.ComputeWithForm(true, false);
notesChildDocument.Save(true, false, true);
}

Hallo,

gibt es eine Möglichkeit herauszufinden, welches NotesItem der Calendar beim öffnen des Termins nicht finden kann? also eine art log?

Bin ganz neu in der Notes-Entwicklung und ich hab keine Ahung welches Item das Dokument noch benötigt.

Bei dem Type Remnider Type (4) funktioniert es, nur bei Appointment (0) nicht,

keiner eine Idee, was ich genau beachten muss?

parent anlegen, child anlegen .. beides speichern ... aber nach der änderung im kalender wird die serie gelöscht

hat jemand ein script in dem er srientermine anlegt, das er mir villeicht posten könnte

okay jetzt hab ich die §ref. leider immernoch das alt bekannte problem, eine änderung und der gesamte termin wird überschrieben. gibts da villeicht etwas, was man ganz besonders beachten muss. außer die felder setzen, die im pdf stehen?

designer hilfe? klär mich ma auf. ich hab einfach die dll in mein .net projhekt eingebunden und angefangen leider

nur um mich ma nich als total dumm zu outen.

vor ner woche kam mein chef und meinte schreib einfach mal ne schnittstelle von userer software nach lotus notes. unser kunde möchte das termine / aufgaben und e -mails in beiden kalendern gleich sind. das ganze für ca. hundert user.

naja also ma domino und lotus notes installiert und angefangen termine / aufgaben und e-mails sind kein problem, auch serientermine von notes in unsere software geht. nur die serientermine nach notes machen mich halt fertig.

wie gesagt, ich bin echt neu in notes.

ich habe zwei notes-dokumente. Einmal den Parent und den Child. diese müssen aber miteinander in verbindung stehen, dies geht anscheind über $Ref.

oder muss ich das Child - Dokument besonders erstellen?

hab einfach

notesDocumentParent = notesDatabase.CreateDocument();
notesDocument = notesDatabase.CreateDocument();

notesDocument.ReplaceItemValue("ApptUNID",notesDocumentParent.UniversalID);

gemacht. und in beiden nach der Anleitung die Felder gefüllt.

nur das Feld $Ref muss gefüllt sein. aber wie? bzw wie kann ich es füllen lassen

so, ich bin ein gutes stück weitergekommen. hab mich durch das pdf gearbeitet und den serientermin anlegen können.

jetzt bekomme ich leider beim öffnen eine fehlermeldung. "wrong datatype"

das liegt daran, das ich das Feld $Ref falsch fülle.

Was muss genau da hinein, die uniqueID des parent - Datensatzes ist ja falsch.
Wie erstelle ich den Datentyp Response Reference List mit dem richtigen Inhalt.

ja habs gefunden sorry, ich schlaf jetzt mal und dann hoffe ich das ich mich halbwegs konzentrieren kann und dann das dokument erstellen kann.

ist sonst nicht meine art als nachzubohren.

schön, aber der link führt leider nicht zu dem redbook was du mir empfohlen hast. naja ich schließe dann mal den thread und werd mich erst ma schlafen legen. sitz seit 20 stunden an dem projekt und muss es so schnell wie möglich aktivieren. bis vor 4 tagen hatte ich keine ahung von lotus notes. geschweige denn wie man auf die schnittstelle zu greift.

sperren von dokumenten geht wahrscheinlich nicht ganz einfach oder?

coole sache, was passiert denn bei euch, wenn ihr einen termin der serie anfasst und im kalender auf einen anderen tag verschiebt. bei mir wird leider aus allen einträgen (z.b. 10) nur noch einer. Genau der, auf den ich den Termin verschoben habe, dabei will ich doch nur einen Termin innerhalb der Serie verschieben.

jetzt bin ich total verwirrt, kann ich einen serientermin in einem notesdokument erstellen? mir wurde immer gesagt es ginge nur mit zweien. :-? übrigens passiert dort genau das gleiche ... wenn ich den termin so erstelle, wird er nach verschieben zu einem zusammengefasst.

aber villeicht könnte man ja einen termin auch sperren, quasi so, das man ihn nur ansehen aber nicht editieren kann. gibts da villeicht ein attribut was du mir nennen könntest. das würde mir für den anfang schon reichen um das system produktiv zu setzen.

aber echt tausend dank das du mir ein paar infos gibst.

tausend dank, könntest du mir den link von der ibm - docu posten? hab leider nichts gefunden. sitz schon seit langer zeit dran

leider habe ich im forum nur maximal das anlegen von normalen terminen gefunden.d as habe ich implementiert. das problem ist wie gesagt das anlegen von serienterminen. dazu finde ich zumindestens nichts im netz bzw im forum.

ich verstehe einfach nicht, wieso er meinen neu angelegten termin als serie anzeigt, aber nicht als serie erkennt und dadurch bei einer änderung eines einzelenen serienelements, die gesamte serie überschrieben wird, und nur ein termin mit dem geänderten datum übrig bleibt.

Hallo,

ich hoffe ihr könnt mir Helfen. Ich muss eine synchronisation von Terminen / Aufgaben zwischen Lotus Notes und einer Oracle Datenbank programmieren. Normale Termine und Aufgaben kann ich synchronisieren.

Dabei gehe ich wie Folgt vor. Ich erstelle ein Notes-Dokument und speicher es.

Bei Serienterminen ist dies ja etwas anders. Dort erstelle ich zwei Dokumente. Ein Parent und ein Child Dokument. Eins besitzt das Feld CalendarDateTime und das andere nicht.

Angenommen ich möchte einen Termin von 5 Tagen erstellen, füge ich in Start, End und CalendardateTime diese 5 Daten ein. Die Beiden Dokumente werden mit der ApptUNID verbunden.

Nach dem Speichern des Dokuments werden die Termine auch im Kalender angezeigt. Bearbeite ich ein Termin (z.b. das Datum ändern) werden alle anderen Daten gelöscht und aus einem wiederholenden wird ein einzelner Termin. (Es wird nicht gefragt ob die änderung für den Tag oder die gesamte Serie übernommen werden soll)

Hat jemand von euch damit schon Erfahrungen???

Ich weis einfach nicht mehr weiter ...